Operação direcionada

Aplica-se a: Databricks SQL Databricks Runtime 16.2 e versões superiores

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

• Cláusula SELECT

  Coleta as colunas a serem retornadas da consulta, incluindo o processamento de expressões e a remoção de duplicações.

  A lista de colunas não deve conter funções de agregação. Use a operação AGGREGATE para essa finalidade.

• 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 são avaliadas como um valor.

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

  • column_alias

    Um identificador de coluna opcional nomeando o resultado da expressão. Se nenhum column_alias for fornecido, o Azure Databricks derivará um.

• SET

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

  A operação é executada na ordem de aparência na cláusula SET. O resultado de qualquer expressão pode observar as colunas atualizadas pelas expressões anteriores.

  • nome_da_coluna

    O nome da coluna a ser atualizado. 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 são avaliadas como um valor.

• DROP column_name [, ...]

  Remove 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. Essa cláusula geralmente segue um ORDER BY para produzir um resultado determinístico.

• OFFSET

  Ignora várias linhas retornadas pela consulta. Essa cláusula normalmente é usada em conjunto com LIMIT para paginar por meio de um conjunto de resultados e ORDER BY para produzir um resultado determinístico.

  Nota

  Ao paginar um conjunto de resultados usando LIMIT e OFFSET todas as linhas são processadas, incluindo linhas ignoradas. No entanto, somente o subconjunto de linhas especificado é retornado no conjunto de resultados. A paginação com essa técnica não é recomendada para consultas com uso intensivo de recursos.

• agregação

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

  Essa operação produz um conjunto de resultados em que as colunas de agrupamento aparecem antes das colunas agregadas.

  • AGREGADO

    Especifica as expressões a serem agregadas.

    • aggregate_expr

      Uma expressão que contém uma ou mais funções de agregação. 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.

  • column_alias

    Um identificador de coluna opcional nomeando o resultado da expressão. Se nenhum column_alias for fornecido, o Azure Databricks derivará um.

• JOIN

  Combina duas ou mais relações usando um join. 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. Esse parâmetro é mutuamente exclusivo com SORT BY, CLUSTER BYe DISTRIBUTE BY e não pode ser especificado em conjunto.

• definir_operador

  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 a perspectiva dos 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 a perspectiva dos 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

Artigos relacionados

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