Opération en pipeline

S’applique à : Databricks SQL Databricks Runtime 16.2 et versions ultérieures

Traite le résultat de la requête précédente à l’aide d’une opération chaînée.

Syntaxe

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

Paramètres

• Clause SELECT

  Collecte les colonnes à retourner à partir de la requête, y compris l’exécution d’expressions et la déduplication.

  La liste de colonnes ne doit pas contenir de fonctions d’agrégation. Utilisez l’opération de AGGREGATE à cet effet.

• ÉTENDRE

  Ajoute de nouvelles colonnes à la liste de sélection de requêtes.

  • expression

    Combinaison d’une ou plusieurs valeurs, opérateurs et fonctions SQL qui sont évaluées à une valeur.

    expression peut contenir des références à des colonnes dans la liste de sélection de requêtes, ainsi que des column_alias précédentes dans cette clause EXTEND.

  • column_alias

    Identificateur de colonne facultatif nommant le résultat de l’expression. Si aucun column_alias n’est fourni, Azure Databricks en dérive un.

• SET

  Remplace les colonnes existantes dans la liste de sélection de requêtes par de nouvelles valeurs.

  L’opération est effectuée dans l’ordre d’apparence dans la clause SET. Le résultat de n'importe quelle expression peut tenir compte des colonnes mises à jour par les expressions précédentes.

  • nom_de_colonne

    Nom de la colonne à mettre à jour. Si la colonne n’existe pas, Azure Databricks génère une erreur UNRESOLVED_COLUMN .

  • expression

    Combinaison d’une ou plusieurs valeurs, opérateurs et fonctions SQL qui sont évaluées à une valeur.

• DROP column_name [, ...]

  Supprime les colonnes de la liste de sélection de requêtes.

  Si la colonne n’existe pas, Azure Databricks génère une erreur UNRESOLVED_COLUMN .

• COMME table_alias

  Attribue un nom au résultat de la requête.

• WHERE

  Filtre le résultat de la requête en fonction des prédicats fournis.

• LIMIT

  Limite le nombre maximal de lignes qui peuvent être retournées par la requête. Cette clause suit généralement une ORDER BY pour produire un résultat déterministe.

• OFFSET

  Ignore un certain nombre de lignes retournées par la requête. Cette clause est principalement utilisée conjointement avec LIMIT pour page par le biais d’un jeu de résultats, et avec ORDER BY pour produire un résultat déterministe.

  Remarque

  Lors de la pagination d’un jeu de résultats à l’aide de LIMIT et OFFSET, toutes les lignes sont traitées, y compris les lignes ignorées. Toutefois, seul le sous-ensemble spécifié de lignes est retourné dans le jeu de résultats. La pagination avec cette technique n’est pas recommandée pour les requêtes gourmandes en ressources.

• agrégation

  Agrège le jeu de résultats de la requête en fonction des expressions fournies et des expressions de regroupement facultatives.

  Cette opération produit un jeu de résultats où les colonnes de regroupement apparaissent avant les colonnes agrégées.

  • AGRÉGAT

    Spécifie les expressions à agréger.

    • aggregate_expr

      Expression contenant une ou plusieurs fonctions d’agrégation. Pour plus d’informations, consultez GROUP BY.

  • GROUP BY

    Spécifie par quelles expressions les lignes sont regroupées. S’il n’est pas spécifié, toutes les lignes sont traitées comme un seul groupe.

    • grouping_expr

      Expression identifiant les colonnes de regroupement. Pour plus d’informations, consultez GROUP BY.

      Contrairement à une clause GROUP BY générique, une valeur numérique intégrale identifie une colonne dans la requête qui fournit l’entrée et non le jeu de résultats généré.

  • column_alias

    Identificateur de colonne facultatif nommant le résultat de l’expression. Si aucun column_alias n’est fourni, Azure Databricks en dérive un.

• JOIN

  Combine deux relations ou plus à l’aide d’une jointure. Pour plus d’informations, consultez JOIN.

• ORDER BY

  Trie les lignes du jeu de résultats de la requête. Les lignes de sortie sont triées sur les partitions. Ce paramètre s’exclue mutuellement avec SORT BY, CLUSTER BYet DISTRIBUTE BY et ne peut pas être spécifié ensemble.

• set_operator

  Combine la requête avec une ou plusieurs sous-requêtes à l’aide de UNION, de EXCEPTou d’opérateurs INTERSECT.

• TABLESAMPLE

  Réduit la taille du jeu de résultats en échantillonnant uniquement une fraction des lignes.

• PIVOT

  Utilisé pour offrir une perspective sur les données. Vous pouvez obtenir les valeurs agrégées en fonction des valeurs de colonne spécifiques. Pour plus d’informations, consultez PIVOT.

• UNPIVOT

  Utilisé pour offrir une perspective sur les données. Vous pouvez fractionner plusieurs groupes de colonnes en lignes. Pour plus d’informations, consultez UNPIVOT.

Exemples

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

Articles connexes

• Clause GROUP BY
• JOIN
• Clause LIMIT
• Clause OFFSET
• Clause ORDER BY
• Clause PIVOT
• Définir des opérateurs
• référence de table
• Clause TABLESAMPLE
• Clause UNPIVOT
• Clause WHERE
• Syntaxe du pipeline SQL
• Requête
• Clause SELECT