Dela via

Piped-åtgärd

  • Artikel

gäller för:markerad med ja Databricks Runtime 16.2 och senare

Bearbetar resultatet av föregående fråga med hjälp av en länkad åtgärd.

Syntax

{ 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 ] ]

Parametrar

  • SELECT-klausul

    Samlar in de kolumner som ska returneras från frågan, inklusive exekvering av uttryck och deduplicering.

    Kolumnlistan får inte innehålla aggregeringsfunktioner. Använd åtgärden AGGREGATE för det ändamålet.

  • UTÖKA

    Lägger till nya kolumner i listan med frågeval.

    • uttryck

      En kombination av ett eller flera värden, operatorer och SQL-funktioner som utvärderas till ett värde.

      expression kan innehålla referenser till kolumner i frågevalslistan samt föregående column_alias i den här EXTEND-satsen.

    • column_alias

      En valfri kolumnidentifierare som namnger uttrycksresultatet. Om column_alias inte tillhandahålls, härleder Azure Databricks en.

  • SET

    Åsidosätter befintliga kolumner i listan med frågeval med nya värden.

    Åtgärden utförs i den ordning som visas i SET-satsen. Resultatet av ett uttryck kan visa vilka kolumner som har uppdaterats av föregående uttryck.

    • kolumnnamn

      Namnet på kolumnen som ska uppdateras. Om kolumnen inte finns genererar Azure Databricks ett UNRESOLVED_COLUMN fel.

    • uttryck

      En kombination av ett eller flera värden, operatorer och SQL-funktioner som utvärderas till ett värde.

  • DROP column_name [, ...]

    Tar bort kolumner från listan med frågeval.

    Om kolumnen inte finns genererar Azure Databricks ett UNRESOLVED_COLUMN fel.

  • AS table_alias

    Tilldelar ett namn till resultatet av frågan.

  • WHERE

    Filtrerar resultatet av frågan baserat på de angivna predikaten.

  • LIMIT

    Begränsar det maximala antalet rader som kan returneras av frågan. Den här satsen följer vanligtvis en ORDER BY för att skapa ett deterministiskt resultat.

  • OFFSET

    Hoppar över ett antal rader som returneras av frågan. Den här satsen används vanligtvis i samband med LIMIT till sida i en resultatuppsättning och ORDER BY för att skapa ett deterministiskt resultat.

    Obs

    När du går igenom en resultatuppsättning med hjälp av LIMIT och OFFSET bearbetas alla rader, inklusive överhoppade rader. Men endast den angivna delmängden av rader returneras i resultatuppsättningen. Sidnumrering med den här tekniken rekommenderas inte för resursintensiva frågor.

  • aggregering

    Aggregerar resultatuppsättningen för frågan baserat på de angivna uttrycken och valfria grupperingsuttryck.

    Den här åtgärden genererar en resultatuppsättning där grupperingskolumnerna visas före de aggregerade kolumnerna.

    • SAMMANSTÄLTA

      Anger de uttryck som ska aggregeras.

    • GROUP BY

      Anger med vilka uttryck raderna grupperas. Om det inte anges behandlas alla rader som en enda grupp.

      • grouping_expr

        Ett uttryck som identifierar grupperingskolumnerna. Mer information finns i GROUP BY.

        Till skillnad från en allmän GROUP BY-sats identifierar ett numeriskt integralvärde en kolumn i frågan som tillhandahåller indata och inte den genererade resultatuppsättningen.

    • column_alias

      En valfri kolumnidentifierare som namnger uttrycksresultatet. Om ingen column_alias tillhandahålls kommer Azure Databricks att härleda en.

  • JOIN

    Kombinerar två eller flera relationer med hjälp av en koppling. Mer information finns i JOIN.

  • ORDER BY

    Beställer raderna i resultatuppsättningen för frågan. Utdataraderna sorteras mellan partitionerna. Den här parametern är ömsesidigt uteslutande med SORT BY, CLUSTER BYoch DISTRIBUTE BY och kan inte anges tillsammans.

  • set_operator

    Kombinerar frågan med en eller flera underfrågor med operatorerna UNION, EXCEPTeller INTERSECT.

  • TABLESAMPLE

    Minskar storleken på resultatuppsättningen genom att endast välja en bråkdel av raderna.

  • PIVOT

    Används för dataperspektiv. Du kan hämta de aggregerade värdena baserat på specifika kolumnvärden. Mer information finns i PIVOT.

  • UNPIVOT

    Används inom datasyfte. Du kan dela upp flera kolumngrupper i rader. Mer information finns i UNPIVOT.

Exempel

-- 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