Operação canalizada

2025-03-12

Aplica-se a: sinal de verificação sim Databricks SQL Databricks Runtime 16.2 e superior

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

Sintaxe

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

Parâmetros

SELECT cláusula

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

A lista de colunas não deve conter funções agregadas. Use a operação AGGREGATE para esse fim.
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. Caso não seja fornecido um column_alias, o Azure Databricks derivará um valor.
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, o Azure Databricks gerará 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, o Azure Databricks gerará 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. Caso não seja fornecido um column_alias, o Azure Databricks derivará um valor.
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 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

Partilhar via

Operação canalizada

Sintaxe

Parâmetros

Exemplos

Artigos relacionados

Comentários

Recursos adicionais