Operace potrubí

platí pro: Databricks Runtime 16.2 a novější

Zpracuje výsledek předchozího dotazu pomocí zřetězených operací.

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

Parametry

• SELECT klauzule

  Shromažďuje sloupce, které se mají vrátit z dotazu, včetně provádění výrazů a odstranění duplicit.

  Seznam sloupců nesmí obsahovat agregační funkce. Pro tento účel použijte operaci AGGREGATE.

• EXTEND

  Připojí nové sloupce do seznamu pro výběr dotazu.

  • expression

    Kombinace jedné nebo více hodnot, operátorů a funkcí SQL, které se vyhodnotí jako hodnota.

    expression mohou obsahovat odkazy na sloupce v seznamu výběrů dotazu i předchozí column_alias v této klauzuli EXTEND.

  • column_alias

    Volitelný identifikátor sloupce určující název výsledku výrazu. Pokud není k dispozici žádná column_alias, Azure Databricks jednu odvodí.

• SET

  Přepíše existující sloupce v seznamu výběru dotazu novými hodnotami.

  Operace se provádí v pořadí výskytu v klauzuli SET. Výsledek libovolného výrazu může zohledňovat sloupce aktualizované předchozími výrazy.

  • column_name

    Název sloupce, který se má aktualizovat. Pokud sloupec neexistuje, Azure Databricks vyvolá chybu UNRESOLVED_COLUMN.

  • výrazu

    Kombinace jedné nebo více hodnot, operátorů a funkcí SQL, které se vyhodnotí jako hodnota.

• DROP column_name [, ...]

  Odebere sloupce ze seznamu výběrů dotazu.

  Pokud sloupec neexistuje, Azure Databricks vyvolá chybu UNRESOLVED_COLUMN.

• AS table_alias

  Přiřadí název výsledku dotazu.

• WHERE

  Filtruje výsledek dotazu na základě zadaných predikátů.

• LIMIT

  Omezí maximální počet řádků, které může dotaz vrátit. Tato klauzule obvykle následuje ORDER BY k vytvoření deterministického výsledku.

• OFFSET

  Přeskočí počet řádků vrácených dotazem. Tato klauzule se obvykle používá ve spojení s LIMIT k stránce prostřednictvím sady výsledků a ORDER BY k vytvoření deterministického výsledku.

  Poznámka

  Při stránkování sady výsledků pomocí LIMIT a OFFSET se zpracovávají všechny řádky, včetně přeskočených řádků. V sadě výsledků se ale vrátí pouze zadaná podmnožina řádků. Stránkování s touto technikou se nedoporučuje pro dotazy náročné na zdroje.

• agregace

  Agreguje sadu výsledků dotazu na základě zadaných výrazů a volitelných výrazů seskupení.

  Tato operace vytvoří sadu výsledků, ve které se sloupce seskupení zobrazí před agregovanými sloupci.

  • AGREGÁT

    Určuje výrazy, které se mají agregovat.

    • agregační_výraz

      Výraz obsahující jednu nebo více agregačních funkcí. Další informace najdete v tématu GROUP BY.

  • GROUP BY

    Určuje, podle kterých výrazů jsou řádky seskupeny. Pokud není zadáno, všechny řádky se považují za jednu skupinu.

    • grouping_expr

      Výraz identifikující sloupce seskupení. Další informace najdete v tématu GROUP BY.

      Na rozdíl od obecné klauzule GROUP BY celočíselná číselná hodnota identifikuje sloupec v dotazu, který poskytuje vstup, a ne vygenerovanou sadu výsledků.

  • column_alias

    Volitelný identifikátor sloupce určující název výsledku výrazu. Pokud není k dispozici žádná column_alias, Azure Databricks jeden odvodí.

• JOIN

  Kombinuje dvě nebo více relací pomocí spojení. Další informace najdete v tématu JOIN.

• ORDER BY

  Seřadí řádky sady výsledků dotazu. Výstupní řádky jsou seřazené napříč particemi. Tento parametr se vzájemně vylučuje s SORT BY, CLUSTER BYa DISTRIBUTE BY a nelze jej zadat společně.

• set_operator

  Kombinuje dotaz s jedním nebo více poddotazů pomocí operátorů UNION, EXCEPTnebo INTERSECT.

• TABLESAMPLE

  Zmenšuje velikost sady výsledků pouze vzorkováním zlomku řádků.

• PIVOT

  Používá se pro pohled na data. Agregované hodnoty můžete získat na základě konkrétních hodnot sloupců. Další informace najdete v tématu PIVOT.

• UNPIVOT

  Používá se pro pohled na data. Můžete rozdělit více skupin sloupců na řádky. Další informace najdete v tématu UNPIVOT.

Příklady

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

Související články

• GROUP BY klauzule
• JOIN
• LIMIT klauzule
• OFFSET klauzule
• ORDER BY klauzule
• PIVOT klauzule
• Set – operátory
• referenční tabulky
• TABLESAMPLE klauzule
• UNPIVOT klauzule
• WHERE klauzule
• syntaxe kanálu SQL
• dotazu
• SELECT klauzule