Operação canalizada

Aplica-se a: Databricks SQL Databricks Runtime 16.2 e superior

Processa o resultado da consulta anterior usando uma operação encadeada.

Sintaxe

{ SELECT clause [ GROUP BY grouping_expr [ AS column_alias ] [, ...] ] |
  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 ] ]

Parâmetros

• SELECT cláusula

  Recolhe as colunas a serem retornadas da consulta, incluindo a execução de expressões e a desduplicação.

  No Databricks Runtime 18.0 ou superior, a lista de colunas pode conter funções agregadas. A cláusula opcional GROUP BY especifica as expressões de agrupamento, e o SELECT operador pipe devolve apenas as expressões anteriores à GROUP BY cláusula. Se GROUP BY for omitido, todas as linhas são tratadas como um único grupo. Para versões anteriores, use a AGGREGATE operação em vez disso.

  • GROUP BY

    Especifica por quais expressões as linhas são agrupadas. Se não for especificado, todas as linhas serão tratadas como um único grupo.

    • grouping_expr

      Uma expressão que identifica as colunas de agrupamento. Consulte GROUP BY para obter mais informações.

    • apelido_coluna

      Um identificador de coluna opcional que nomeia o resultado da expressão de agrupamento. Se não for fornecido column_alias, Azure Databricks deriva um.

• ESTENDER

  Acrescenta novas colunas à lista de seleção de consulta.

  • expressão

    Uma combinação de um ou mais valores, operadores e funções SQL que é avaliada como um valor.

    expression pode conter referências a colunas na lista de seleção de consulta, bem como column_alias anteriores nesta cláusula EXTEND.

  • apelido_coluna

    Um identificador de coluna opcional nomeando o resultado da expressão. Se não for fornecido column_alias Azure Databricks deriva um.

• SET

  Substitui colunas existentes na lista de seleção de consulta por novos valores.

  A operação é realizada na ordem de aparição na cláusula SET. O resultado de qualquer expressão pode refletir as colunas atualizadas pelas expressões anteriores.

  • nome_coluna

    O nome da coluna a ser atualizada. Se a coluna não existir, Azure Databricks gera um erro UNRESOLVED_COLUMN.

  • expressão

    Uma combinação de um ou mais valores, operadores e funções SQL que é avaliada como um valor.

• DROP column_name [, ...]

  Remova as colunas da lista de seleção da consulta.

  Se a coluna não existir, Azure Databricks gera um erro UNRESOLVED_COLUMN.

• COMO table_alias

  Atribui um nome ao resultado da consulta.

• WHERE

  Filtra o resultado da consulta com base nos predicados fornecidos.

• LIMIT

  Limita o número máximo de linhas que podem ser retornadas pela consulta. Esta cláusula geralmente segue um ORDER BY para produzir um resultado determinístico.

• OFFSET

  Ignora várias linhas retornadas pela consulta. Esta cláusula é normalmente usada em conjunto com LIMIT a na página para percorrer um conjunto de resultados, e com ORDER BY para produzir um resultado determinístico.

  Observação

  Ao paginar um conjunto de resultados usando LIMIT e OFFSET todas as linhas são processadas, incluindo linhas ignoradas. No entanto, apenas o subconjunto especificado de linhas é retornado no conjunto de resultados. A paginação com esta técnica não é aconselhada para consultas que consomem muitos recursos.

• agregação

  Agrega o conjunto de resultados da consulta com base nas expressões fornecidas e expressões de agrupamento opcionais.

  Esta operação produz um conjunto de resultados onde as colunas de agrupamento aparecem antes das colunas agregadas.

  • AGREGADO

    Especifica as expressões a serem agregadas.

    • expressão_agregada

      Uma expressão que contém uma ou mais funções agregadas. Consulte GROUP BY para obter mais informações.

  • GROUP BY

    Especifica por quais expressões as linhas são agrupadas. Se não for especificado, todas as linhas serão tratadas como um único grupo.

    • grouping_expr

      Uma expressão que identifica as colunas de agrupamento. Consulte GROUP BY para obter mais informações.

      Ao contrário de uma cláusula GROUP BY genérica, um valor numérico integral identifica uma coluna na consulta que fornece a entrada, e não o conjunto de resultados gerado.

  • apelido_coluna

    Um identificador de coluna opcional nomeando o resultado da expressão. Se não for fornecido column_alias Azure Databricks deriva um.

• JOIN

  Combina duas ou mais relações utilizando uma junção. Consulte JOIN para obter mais informações.

• ORDER BY

  Ordena as linhas do conjunto de resultados da consulta. As linhas de saída são ordenadas entre as partições. Este parâmetro é mutuamente exclusivo com SORT BY, CLUSTER BYe DISTRIBUTE BY e não pode ser especificado em conjunto.

• set_operator

  Combina a consulta com uma ou mais subconsultas usando operadores UNION, EXCEPTou INTERSECT.

• TABLESAMPLE

  Reduz o tamanho do conjunto de resultados amostrando apenas uma fração das linhas.

• PIVOT

  Usado para perspetiva de dados. Você pode obter os valores agregados com base em valores de coluna específicos. Consulte PIVOT para obter mais informações.

• UNPIVOT

  Usado para perspetiva de dados. Você pode dividir vários grupos de colunas em linhas. Consulte UNPIVOT para obter mais informações.

Exemplos

-- 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 | as the pipe token (DBR 18.0 and above)
> CREATE TABLE t AS VALUES (0, 1), (0, 2) AS t(a, b);

> FROM t
  | WHERE a < 2
  | SELECT a, SUM(b) AS total GROUP BY a;
  a  total
  -  -----
  0      3

-- Using SELECT with aggregates and GROUP BY (DBR 18.0 and above)
> VALUES (0, 1), (0, 2), (1, 3) tab(a, b)
  |> SELECT a, SUM(b) AS total GROUP BY a;
 a  total
 -  -----
 0      3
 1      3

-- Full-table aggregation using SELECT (DBR 18.0 and above)
> VALUES (0), (1), (2) tab(col)
  |> SELECT SUM(col) AS total;
 total
 -----
     3

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

Artigos relacionados

• GROUP BY cláusula
• JOIN
• LIMIT cláusula
• OFFSET cláusula
• ORDER BY cláusula
• PIVOT cláusula
• Definir operadores
• tabela de referência
• TABLESAMPLE cláusula
• UNPIVOT cláusula
• WHERE cláusula
• Sintaxe do Pipeline SQL
• Consulta
• SELECT cláusula