Weitergeleiteter Vorgang

Gilt für: Databricks Runtime 16.2 und höher

Verarbeitet das Ergebnis der vorherigen Abfrage mithilfe eines verketteten Vorgangs.

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

Parameter

• SELECT Klausel

  Sammelt die Spalten, die von der Abfrage zurückgegeben werden sollen, einschließlich der Ausführung von Ausdrücken und Deduplizierung.

  Die Spaltenliste darf keine Aggregatfunktionen enthalten. Verwenden Sie dazu den AGGREGATE Vorgang.

• EXTEND

  Fügt neue Spalten an die Abfrageauswahlliste an.

  • expression

    Eine Kombination aus einer oder mehreren Werten, Operatoren und SQL-Funktionen, die zu einem Wert ausgewertet werden.

    expression kann Verweise auf Spalten in der Abfrageauswahlliste sowie ein vorangehendes column_alias-Element in dieser EXTEND-Klausel enthalten.

  • column_alias

    Ein optionaler Spaltenbezeichner, der das Ausdrucksergebnis benennt. Wenn kein column_alias-Element angegeben wird, leitet Azure Databricks eines ab.

• SET

  Überschreibt vorhandene Spalten in der Abfrageauswahlliste mit neuen Werten.

  Der Vorgang wird in der Reihenfolge der Darstellung in der SET-Klausel ausgeführt. Das Ergebnis eines beliebigen Ausdrucks kann die Spalten beobachten, die durch vorangehende Ausdrücke aktualisiert wurden.

  • Spaltenname

    Der Name der spalte, die aktualisiert werden soll. Wenn die Spalte nicht vorhanden ist, löst Azure Databricks einen UNRESOLVED_COLUMN Fehler aus.

  • expression

    Eine Kombination aus einer oder mehreren Werten, Operatoren und SQL-Funktionen, die zu einem Wert ausgewertet werden.

• DROP column_name [, …]

  Entfernt Spalten aus der Abfrageauswahlliste.

  Wenn die Spalte nicht vorhanden ist, löst Azure Databricks einen UNRESOLVED_COLUMN Fehler aus.

• AS table_alias

  Weist dem Ergebnis der Abfrage einen Namen zu.

• WHERE

  Filtert das Ergebnis der Abfrage basierend auf den bereitgestellten Prädikaten.

• LIMIT

  Beschränkt die maximale Anzahl von Zeilen, die von der Abfrage zurückgegeben werden können. Diese Klausel folgt in der Regel einem ORDER BY, um ein deterministisches Ergebnis zu erzeugen.

• OFFSET

  Überspringt eine Anzahl von Zeilen, die von der Abfrage zurückgegeben werden. Diese Klausel wird normalerweise zusammen mit LIMIT verwendet, um durch ein Resultset zu blättern, und zusammen mit ORDER BY, um ein deterministisches Ergebnis zu erzeugen.

  Anmerkung

  Beim Ausblättern eines Resultsets mithilfe von LIMIT und OFFSET werden alle Zeilen verarbeitet, einschließlich übersprungener Zeilen. Im Resultset wird jedoch nur die angegebene Teilmenge der Zeilen zurückgegeben. Die Paginierung mit dieser Technik wird für ressourcenintensive Abfragen nicht empfohlen.

• aggregation

  Aggregiert das Resultset der Abfrage basierend auf den bereitgestellten Ausdrücken und optionalen Gruppierungsausdrücken.

  Dieser Vorgang erzeugt ein Resultset, in dem die Gruppierungsspalten vor den aggregierten Spalten angezeigt werden.

  • AGGREGATE

    Gibt die ausdrücke an, die aggregiert werden sollen.

    • aggregate_expr

      Ein Ausdruck, der eine oder mehrere Aggregatfunktionen enthält. Weitere Informationen finden Sie unter GROUP BY.

  • GROUP BY

    Gibt an, nach welchen Ausdrücken die Zeilen gruppiert werden. Wenn nicht angegeben, werden alle Zeilen als einzelne Gruppe behandelt.

    • grouping_expr

      Ein Ausdruck, der die Gruppierungsspalten identifiziert. Weitere Informationen finden Sie unter GROUP BY.

      Im Gegensatz zu einer generischen GROUP BY-Klausel identifiziert ein ganzzahliger Wert eine Spalte in der Abfrage, die die Eingabe liefert, und nicht die generierte Ergebnismenge.

  • column_alias

    Ein optionaler Spaltenbezeichner, der das Ausdrucksergebnis benennt. Wenn kein column_alias-Element angegeben wird, leitet Azure Databricks eines ab.

• JOIN

  Kombiniert zwei oder mehr Beziehungen mithilfe eines Joins. Weitere Informationen finden Sie unter JOIN.

• ORDER BY

  Sortiert die Zeilen des Resultsets der Abfrage. Die Ausgabezeilen werden über die Partitionen sortiert. Dieser Parameter schließt sich gegenseitig mit SORT BY, CLUSTER BYund DISTRIBUTE BY aus und kann nicht zusammen angegeben werden.

• set_operator

  Kombiniert die Abfrage mit einer oder mehreren Unterabfragen mit UNION, EXCEPToder INTERSECT Operatoren.

• TABLESAMPLE

  Reduziert die Größe des Resultsets, indem nur ein Bruchteil der Zeilen ausgewählt wird.

• PIVOT

  Wird für die Datenperspektive verwendet. Sie können die aggregierten Werte basierend auf bestimmten Spaltenwerten abrufen. Weitere Informationen finden Sie unter PIVOT.

• UNPIVOT

  Wird für die Datenperspektive verwendet. Sie können mehrere Spaltengruppen in Zeilen aufteilen. Weitere Informationen finden Sie unter UNPIVOT.

Beispiele

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

Verwandte Artikel

• GROUP BY Klausel
• JOIN
• LIMIT Klausel
• OFFSET Klausel
• ORDER BY Klausel
• PIVOT Klausel
• Festlegen von Operatoren
• Tabellenverweis
• TABLESAMPLE Klausel
• UNPIVOT Klausel
• WHERE Klausel
• SQL-Pipeline-Syntax
• Abfrage
• SELECT Klausel