Pijpbewerking

Van toepassing op: Databricks Runtime 16.2 en hoger

Verwerkt het resultaat van de voorgaande query met behulp van een gekoppelde bewerking.

Syntaxis

{ SELECT clause |
  EXTEND { expression [ [ AS ] column_alias ] } [ , ...] |
  SET { column_name = expression } [, ...] |
  DROP column_name [, ...] |
  AS table_alias |
  WHERE clause |
  { LIMIT clause |
    OFFSET clause |
    LIMIT clause OFFSET clause } |
  aggregation |
  JOIN clause |
  ORDER BY clause |
  set_operator |
  TABLESAMPLE clause
  PIVOT clause
  UNPIVOT clause }

 aggregation
   AGGREGATE aggregate_expr [ [ AS ] column_alias ] [, ...]
   [ GROUP BY grouping_expr [AS column_alias ] ]

Parameters

• SELECT clausule

  Verzamelt de kolommen die moeten worden geretourneerd uit de query, inclusief het uitvoeren van expressies en deduplicatie.

  De kolomlijst mag geen statistische functies bevatten. Gebruik hiervoor de AGGREGATE-bewerking.

• uitbreiden

  Voegt nieuwe kolommen toe aan de selectielijst van de query.

  • uitdrukking

    Een combinatie van een of meer waarden, operators en SQL-functies die een waarde opleveren.

    expression kan verwijzingen naar kolommen in de selectielijst van de query bevatten, evenals voorgaande column_alias in deze EXTEND clausule.

  • column_alias

    Een optionele kolomidentificatie die het expressieresultaat benoemt. Als er geen column_alias is opgegeven, leidt Azure Databricks er een af.

• SET

  Hiermee overschrijft u bestaande kolommen in de selectielijst van de query met nieuwe waarden.

  De bewerking wordt uitgevoerd in de volgorde van optreden in de SET-clausule. Het resultaat van een expressie kan de kolommen bekijken die zijn bijgewerkt door voorgaande expressies.

  • kolom_naam

    De naam van de kolom die moet worden bijgewerkt. Als de kolom niet bestaat, genereert Azure Databricks een UNRESOLVED_COLUMN fout.

  • expressie

    Een combinatie van een of meer waarden, operators en SQL-functies die een waarde opleveren.

• DROP column_name [, ...]

  Hiermee verwijdert u kolommen uit de selectielijst van de query.

  Als de kolom niet bestaat, genereert Azure Databricks een UNRESOLVED_COLUMN fout.

• AS table_alias

  Hiermee wordt een naam toegewezen aan het resultaat van de query.

• WHERE

  Hiermee filtert u het resultaat van de query op basis van de opgegeven predicaten.

• LIMIT

  Hiermee beperkt u het maximum aantal rijen dat door de query kan worden geretourneerd. Deze clausule volgt meestal een ORDER BY om een deterministisch resultaat te produceren.

• OFFSET

  Slaat een aantal rijen over die door de query worden geretourneerd. Deze component wordt doorgaans gebruikt in combinatie met LIMIT om pagina te via een resultatenset en ORDER BY om een deterministisch resultaat te produceren.

  Notitie

  Wanneer u door een resultatenset bladert met behulp van LIMIT en OFFSET alle rijen worden verwerkt, inclusief overgeslagen rijen. Alleen de opgegeven subset van rijen wordt echter geretourneerd in de resultatenset. Paginering met deze techniek wordt niet geadviseerd voor resource-intensieve query's.

• aggregatie

  Hiermee wordt de resultatenset van de query samengevoegd op basis van de opgegeven expressies en optionele groeperingsexpressies.

  Deze bewerking produceert een resultatenset waarin de groeperingskolommen vóór de samengevoegde kolommen worden weergegeven.

  • AGGREGAAT

    Hiermee geeft u de expressies op die moeten worden samengevoegd.

    • aggregate_expr

      Een expressie met een of meer statistische functies. Zie GROUP BY voor meer informatie.

  • GROUP BY

    Hiermee specificeert u door welke expressies de rijen worden gegroepeerd. Als dit niet is opgegeven, worden alle rijen behandeld als één groep.

    • groepering_expr

      Een expressie die de groeperingskolommen identificeert. Zie GROUP BY voor meer informatie.

      In tegenstelling tot een algemene GROUP BY component identificeert een integrale numerieke waarde een kolom in de query die de invoer levert en niet de gegenereerde resultatenset.

  • column_alias

    Een optionele kolom-id die de naam geeft aan het resultaat van de expressie. Als er geen column_alias is opgegeven, leidt Azure Databricks er een af.

• JOIN

  Combineert twee of meer relaties met behulp van een join. Zie JOIN voor meer informatie.

• ORDER BY

  Hiermee worden de rijen van de resultatenset van de query geordenen. De uitvoerrijen worden gerangschikt op de partities. Deze parameter is wederzijds exclusief met SORT BY, CLUSTER BYen DISTRIBUTE BY en kan niet samen worden opgegeven.

• set_operator

  Combineert de query met een of meer subquery's met behulp van UNION, EXCEPTof INTERSECT operators.

• TABLESAMPLE

  Hiermee verkleint u de grootte van de resultatenset door alleen een fractie van de rijen te nemen.

• PIVOT

  Wordt gebruikt voor gegevensperspectief. U kunt de geaggregeerde waarden ophalen op basis van specifieke kolomwaarden. Zie PIVOT voor meer informatie.

• UNPIVOT

  Wordt gebruikt voor gegevensperspectief. U kunt meerdere kolomgroepen splitsen in rijen. Zie UNPIVOT voor meer informatie.

Voorbeelden

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

is equivalent to:

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

-- Using the SELECT clause following a FROM clause
> CREATE TABLE t AS VALUES (0), (1) AS t(col);

> FROM t
  |> SELECT col * 2 AS result;
 result
 ------
      0
      2

-- Adding columns to the result set
> VALUES (0), (1) tab(col)
  |> EXTEND col * 2 AS result;
 col result
 --- ------
   0      0
   1      2

-- Replacing an expression
> VALUES (0), (1) tab(col)
  |> SET col = col * 2;
 col
 ---
   0
   2

-- Removing a column from the result set
> VALUES (0, 1) tab(col1, col2)
  |> DROP col1;
 col2
 ----
    1

-- Using a table alias
> VALUES (0, 1) tab(col1, col2)
  |> AS new_tab
  |> SELECT col1 + col2 FROM new_tab;
  col1 + col2
            1

-- Filtering the result set
> VALUES (0), (1) tab(col)
  |> WHERE col = 1;
 col
 ---
   1

-- Using LIMIT to truncate the result
> VALUES (0), (0) tab(col)
  |> LIMIT 1;
 col
 ---
   0

-- Full-table aggregation
> VALUES (0), (1) tab(col)
  |> AGGREGATE COUNT(col) AS count;
 count
 -----
     2

-- Aggregation with grouping
> VALUES (0, 1), (0, 2) tab(col1, col2)
  |> AGGREGATE COUNT(col2) AS count GROUP BY col1;
 col1 count
 ---- -----
    0     2

-- Using JOINs
> SELECT 0 AS a, 1 AS b
  |> AS lhs
  |> JOIN VALUES (0, 2) rhs(a, b) ON (lhs.a = rhs.a);
   a   b   c   d
 --- --- --- ---
   0   1   0   2

> VALUES ('apples', 3), ('bananas', 4) t(item, sales)
  |> AS produce_sales
  |> LEFT JOIN
       (SELECT "apples" AS item, 123 AS id) AS produce_data
       USING (item)
  |> SELECT produce_sales.item, sales, id;
   item      sales   id
  --------- ------- ------
  apples    3       123
  bananas   4       NULL

-- Using ORDER BY
> VALUES (0), (1) tab(col)
  |> ORDER BY col DESC;
 col
 ---
   1
   0

> VALUES (0), (1) tab(a, b)
  |> UNION ALL VALUES (2), (3) tab(c, d);
   a    b
 --- ----
   0    1
   2    3

-- Sampling the result set
> VALUES (0), (0), (0), (0) tab(col)
  |> TABLESAMPLE (1 ROWS);
 col
 ---
   0

> VALUES (0), (0) tab(col)
  |> TABLESAMPLE (100 PERCENT);
 col
 ---
   0
   0

-- Pivoting a query
> VALUES
    ("dotNET", 2012, 10000),
    ("Java", 2012, 20000),
    ("dotNET", 2012, 5000),
    ("dotNET", 2013, 48000),
    ("Java", 2013, 30000)
    AS courseSales(course, year, earnings)
  |> PIVOT (
       SUM(earnings)
       FOR COURSE IN ('dotNET', 'Java')
    )
 year dotNET   Java
 ---- ------ ------
 2012  15000  20000
 2013  48000  30000

-- Using UNPIVOT
> VALUES
    ("dotNET", 2012, 10000),
    ("Java", 2012, 20000),
    ("dotNET", 2012, 5000),
    ("dotNET", 2013, 48000),
    ("Java", 2013, 30000)
  AS courseSales(course, year, earnings)
  |> UNPIVOT (
    earningsYear FOR `year` IN (`2012`, `2013`, `2014`)
   course   year earnings
 -------- ------ --------
     Java   2012    20000
     Java   2013    30000
   dotNET   2012    15000
   dotNET   2013    48000
   dotNET   2014    22500

Verwante artikelen

• GROUP BY clausule
• JOIN
• LIMIT clausule
• OFFSET clausule
• ORDER BY clausule
• PIVOT clausule
• operators instellen
• tabelreferentie
• TABLESAMPLE clausule
• UNPIVOT clausule
• WHERE clausule
• SQL-pijplijnsyntaxis
• Query
• SELECT clausule