BigQuery se pypsintaksis: Maak SQL makliker, vinniger en meer leesbaar

William KarrNovember 03, 2025

6 minute lees

Hoe om BigQuery Pipe-sintaksis te gebruik

Enigiemand wat saam met SQL ken die liefde-haat-verhouding wat daarmee gepaardgaan. SQL is kragtig, gestandaardiseerd en ekspressief—maar dit is ook een van die mees onintuïtiewe tale om op skaal te lees en te onderhou. Hoe dieper jou navraag word, hoe moeiliker word dit om te verstaan wat eintlik gebeur en in watter volgorde.

Dit is omdat SQL nie vloei in die volgorde wat jy dink nie. Jy begin deur te skryf SELECT, maar die databasis verwerk dit nie eintlik eers nie. Die enjin begin met die FROM klousule, voeg dan data bymekaar, filter dit, aggregeer dit, en pas eers later sortering en projeksie toe. Die resultaat is 'n navraag wat geskryf is agteruit relatief tot die manier waarop dit uitgevoer word.

Hierdie wanverhouding tussen sintaksis en uitvoering maak SQL beide kognitief swaar en berekeningsduur. Ontleders maak dikwels staat op subnavrae of algemene tabeluitdrukkings (CTE's) om 'n bo-na-onder vloei te simuleer, wat onnodige kompleksiteit en oortolligheid byvoeg. Selfs ervare gebruikers ontfout geneste blokke logika in plaas daarvan om te fokus op die probleem wat hulle oplos.

Om dit aan te spreek, BigQuery supports1s word in dieselfde volgorde uitgevoer as wat hulle gelees word. In plaas daarvan om logika binne-in-buite te skryf, skryf jy dit stap vir stap, soos 'n datapyplyn—elke lyn verteenwoordig 'n afsonderlike transformasie. Die resultaat is SQL wat makliker is om te verstaan, makliker om te ontfout, en baie meer intuïtief vir moderne data-analise.

Die bostaande beeld illustreer die kernprobleem wat pyp-sintaksis oplos. In tradisionele SQL, die sintaktiese volgorde (hoe jy 'n navraag skryf) is verkeerd in lyn met die semantiese volgorde (hoe die databasis dit eintlik verwerk). Byvoorbeeld, SELECT verskyn bo-aan, maar die enjin evalueer dit eers nadat die samevoeging, filtering, groepering en sortering gedoen is.

Hierdie volgorde verteenwoordig die logiese en sintaktiese vloei van 'n BigQuery-pypnavraag – van bo na onder, van links na regs – en weerspieël hoe die databasis die data eintlik verwerk.

VAN: Die beginpunt van enige pypnavraag. Definieer die aanvanklike tabel of subnavraag waaruit data vloei. In pypsintaksis, FROM kan alleen staan as 'n geldige navraag en dien as die ingang tot 'n opeenvolgende pyplyn.
SLUIT AAN: Brei die huidige tabel uit met bykomende kolomme en rye van 'n ander tabel of subnavraag. Kan verskeie kere agtereenvolgens gebruik word (|> JOIN table USING (key)), wat links-diep verbindingsbome leesbaar maak sonder geneste subnavrae.
STEL: Dateer bestaande kolomwaardes op (|> SET column = expressionFunksies soos SELECT * REPLACE(...) in standaard SQL, maar is meer leesbaar en modulêr wanneer dit as 'n pyplynstap gebruik word.
VERLENG: Voeg berekende kolomme by die bestaande datastel (|> EXTEND expression AS new_column). Soortgelyk aan SELECT *, new_column in standaard SQL, maar laat die inkrementele skepping van afgeleide velde tussen ander bewerkings soos samevoegings en filters toe.
LAAT: Verwyder een of meer kolomme uit die huidige datastel (|> DROP column_name). Gelykstaande aan SELECT * EXCEPT(column) in standaard SQL en word dikwels gebruik om uitvoer te vereenvoudig of intermediêre datagrootte te verminder.
WAAR: Filter rye wat aan 'n voorwaarde voldoen (|> WHERE condition). Kan enige plek in die pyplyn verskyn, voor of na aggregasie, wat die behoefte aan verskillende sleutelwoorde soos HAVING of QUALIFY uitskakel.
AGGREGATE: Voer volledige tabel- of gegroepeerde aggregasies uit (|> AGGREGATE SUM(column) AS total GROUP BY category). Vervang GROUP BY en aggregaatfunksies binne SELECT, wat die sintaksis vereenvoudig en dit in lyn bring met die logiese volgorde van bewerkings.
BESTEL DEUR: Sorteer rye in stygende of dalende volgorde (|> ORDER BY column DESC). Lewer 'n geordende resultaattabel wat deur operatore soos gevolg kan word LIMIT.
perk: Beperk die aantal rye in die resultaat (|> LIMIT 10Werk daarna. ORDER BY of op ongeordende tabelle, wat die natuurlike volgorde van filters en aggregasies behou.
OPROEP: Voer 'n tabelgewaardeerde funksie of masjienleermodel uit deur die huidige tabel as invoer te gebruik (|> CALL ML.PREDICT(MODEL project.model_name)). Elimineer die behoefte aan geneste funksieoproepe, wat 'n lineêre en leesbare werkvloei skep.
KIES: Definieer die finale projeksie van kolomme om in die uitvoer in te sluit (|> SELECT column1, column2). Dien as die afsluitende operasie in 'n pyplyn, soortgelyk aan die finale SELECT in 'n standaard SQL-navraag.

Hieronder is die mees algemene scenario's waar pypsintaksis SQL-logika vereenvoudig, wat navrae skoner en vinniger maak om mee te werk.

Aggregering van data sonder subnavrae

Aggregasies is waar SQL begin voel asof dit van binne na buite is. As jy iets wil tel, tel dan daardie tellings, en jy is skielik in die hel tussen hakies.

SQL

SELECT c_count, COUNT(*) AS custdist
FROM (
  SELECT c_custkey, COUNT(o_orderkey) AS c_count
  FROM customer
  JOIN orders ON c_custkey = o_custkey
  WHERE o_comment NOT LIKE '%unusual%packages%'
  GROUP BY c_custkey
)
GROUP BY c_count
ORDER BY custdist DESC;

Pypsintaks

FROM customer
|> JOIN orders ON c_custkey = o_custkey
   AND o_comment NOT LIKE '%unusual%packages%'
|> AGGREGATE COUNT(o_orderkey) AS c_count GROUP BY c_custkey
|> AGGREGATE COUNT(*) AS custdist GROUP BY c_count
|> ORDER BY custdist DESC;

Geen meer neste of dubbele groepering nie. Elke stap vloei logies en kan onafhanklik gewysig word sonder om die hele navraag te herskryf.

Skoonmaak en transformasie van kolomme stap vir stap

Wanneer jy teks in kleinletters moet skryf, totale moet bereken en ekstra kolomme moet weglaat, dwing standaard SQL jou om verskeie te herskryf SELECT stellings. Pyp-sintaksis stel bekend SET, EXTEND, en DROP operateurs sodat jy veranderinge in volgorde kan toepas.

SQL

SELECT o_custkey, ROUND(o_totalprice) AS total_price
FROM (
  SELECT
    o_custkey,
    o_totalprice,
    LOWER(o_orderstatus) AS o_orderstatus
  FROM orders
)
WHERE total_price > 1000;

Pypsintaks

FROM orders
|> SET o_orderstatus = LOWER(o_orderstatus)
|> EXTEND ROUND(o_totalprice) AS total_price
|> WHERE total_price > 1000
|> SELECT o_custkey, total_price;

Elke bewerking bou voort op die vorige een, wat dit makliker maak om transformasies na te spoor en logika te hergebruik.

Filtrering na samevoeging sonder om "HET" te onthou

Een van SQL se eienaardighede is dat die tydsberekening van filters verander afhangende van die klousule. Jy gebruik WHERE voor groepering en HAVING na, maar in werklikheid filter albei net rye. Pipe-sintaksis laat jou toe om te gebruik WHERE konsekwent, maak nie saak waar jy dit plaas nie.

SQL

SELECT department, COUNT(*) AS emp_count
FROM employees
WHERE active = TRUE
GROUP BY department
HAVING COUNT(*) > 5;

Pypsintaks

FROM employees
|> WHERE active = TRUE
|> AGGREGATE COUNT(*) AS emp_count GROUP BY department
|> WHERE emp_count > 5;

Nou kan jy filters skryf in dieselfde volgorde as wat jy daaraan dink: filtreer eers die data, groepeer dit dan, en filter dan weer op die resultate.

Ontfoutingsnavrae sonder tydelike tabelle

In standaard SQL vereis die kontrolering van 'n tussentydse resultaat die skep van 'n tydelike tabel of die toedraai van die kode in verskeie CTE's. Met pyp-sintaksis kan jy die navraag tot enige punt in die pyplyn uitvoer.

SQL

WITH filtered AS (
  SELECT * FROM orders WHERE o_totalprice > 500
),
summed AS (
  SELECT o_custkey, SUM(o_totalprice) AS total
  FROM filtered GROUP BY o_custkey
)
SELECT * FROM summed WHERE total > 10000;

Pypsintaks

FROM orders
|> WHERE o_totalprice > 500
|> AGGREGATE SUM(o_totalprice) AS total GROUP BY o_custkey
|> WHERE total > 10000;

Elke voorvoegsel van die navraag is op sy eie uitvoerbaar, wat beteken dat jy op enige stadium na die data kan "loer". Dit is 'n skoner, meer interaktiewe manier om te ontfout en te herhaal.

Modelle en Funksies Kettings Sonder Nesting

Wanneer daar met tabelgewaardeerde funksies of BigQuery ML-modelle gewerk word, kan neswerk vinnig onleesbaar raak. Pyp-sintaksis vervang daardie geneste oproepe met lineêre kettingwerk met behulp van CALL.

SQL

SELECT *
FROM ML.PREDICT(
  MODEL `project.sentiment_model`,
  (SELECT text FROM reviews)
);

Pypsintaks

SELECT text FROM reviews
|> CALL ML.PREDICT(MODEL `project.sentiment_model`);

As jy verskeie modelle of transformasies toepas, stapel jy eenvoudig bykomende CALL-lyne—geen hakies nodig nie.

Draai data sonder geneste seleksies

Die draai van data was nog altyd 'n moeisame proses, wat dikwels lae subnavrae vereis. Die pypsintaksis vereenvoudig dit in een vloeiende volgorde.

SQL

SELECT *
FROM (
  SELECT n_name, c_acctbal, c_mktsegment
  FROM customer JOIN nation USING (n_nationkey)
)
PIVOT(SUM(c_acctbal) FOR n_name IN ('PERU', 'KENYA', 'JAPAN'));

Pypsintaks

FROM customer
|> JOIN nation USING (n_nationkey)
|> SELECT n_name, c_acctbal, c_mktsegment
|> PIVOT(SUM(c_acctbal) FOR n_name IN ('PERU', 'KENYA', 'JAPAN'));

Die navraag lees nou soos 'n storie: begin met jou data, voeg dit by, kies wat jy nodig het, en draai dan.

Waarom pypsintaksis 'n spelwisselaar is

Pyp-sintaksis herontdek nie SQL nie—dit verduidelik dit. Dit bewaar alles kragtigs omtrent SQL se verklarende struktuur, maar verwyder die kognitiewe oorhoofse koste van die agteruit skryf van logika.

Vir datawetenskaplikes, ontleders en ingenieurs beteken dit: