Operación mediante tubería

Se aplica a: Databricks SQL Databricks Runtime 16.2 y versiones posteriores

Procesa el resultado de la consulta anterior mediante una operación encadenada.

Sintaxis

{ 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

  Recopila las columnas que se van a devolver de la consulta, incluida la ejecución de expresiones y la desduplicación.

  La lista de columnas no debe contener funciones de agregado. Use la operación AGGREGATE para ese propósito.

• EXTENDER

  Anexa nuevas columnas a la lista de selección de consultas.

  • expresión

    Combinación de uno o varios valores, operadores y funciones SQL que se evalúan como un valor.

    expression puede contener referencias a columnas de la lista de selección de consultas, así como referencias a column_alias anteriores en esta cláusula EXTEND.

  • column_alias

    Identificador de columna opcional que denomina el resultado de la expresión. Si no se proporciona ningún column_alias, Azure Databricks deriva uno.

• SET

  Invalida las columnas existentes en la lista de selección de consultas con nuevos valores.

  La operación se realiza en el orden en que aparecen en la cláusula SET. El resultado de cualquier expresión puede reflejar las columnas actualizadas por expresiones anteriores.

  • nombre_de_columna

    Nombre de la columna que se va a actualizar. Si la columna no existe, Azure Databricks genera un error UNRESOLVED_COLUMN.

  • expresión

    Combinación de uno o varios valores, operadores y funciones SQL que se evalúan como un valor.

• DROP column_name [, ...]

  Quita las columnas de la lista de selección de consultas.

  Si la columna no existe, Azure Databricks genera un error UNRESOLVED_COLUMN.

• COMO table_alias

  Asigna un nombre al resultado de la consulta.

• WHERE

  Filtra el resultado de la consulta en función de los predicados proporcionados.

• LIMIT

  Limita el número máximo de filas que puede devolver la consulta. Esta cláusula suele seguir un ORDER BY para generar un resultado determinista.

• OFFSET

  Omite una serie de filas devueltas por la consulta. Esta cláusula se usa normalmente junto con LIMIT para página a través de un conjunto de resultados y ORDER BY para generar un resultado determinista.

  Nota

  Al paginar a través de un conjunto de resultados mediante LIMIT y OFFSET se procesan todas las filas, incluidas las filas omitidas. Sin embargo, solo se devuelve el subconjunto especificado de filas en el conjunto de resultados. No se recomienda la paginación con esta técnica para las consultas que consumen muchos recursos.

• agregación

  Agrega el conjunto de resultados de la consulta en función de las expresiones proporcionadas y las expresiones de agrupación opcionales.

  Esta operación genera un conjunto de resultados donde aparecen las columnas de agrupación antes de las columnas agregadas.

  • AGREGADO

    Especifica las expresiones que se van a agregar.

    • aggregate_expr

      Expresión que contiene una o varias funciones de agregado. Consulte GROUP BY para obtener más información.

  • GROUP BY

    Especifica por qué expresiones se agrupan las filas. Si no se especifica, todas las filas se tratan como un único grupo.

    • grouping_expr

      Expresión que identifica las columnas de agrupación. Consulte GROUP BY para obtener más información.

      A diferencia de una cláusula de GROUP BY genérica, un valor numérico entero identifica una columna en la consulta que proporciona la entrada y no el conjunto de resultados generado.

  • column_alias

    Identificador de columna opcional que denomina el resultado de la expresión. Si no se proporciona ningún column_alias, Azure Databricks deriva uno.

• JOIN

  Combina dos o más relaciones mediante una combinación. Consulte JOIN para obtener más información.

• ORDER BY

  Ordena las filas del conjunto de resultados de la consulta. Las filas de salida se ordenan entre las particiones. Este parámetro es mutuamente excluyente con SORT BY, CLUSTER BYy DISTRIBUTE BY y no se puede especificar juntos.

• set_operator

  Combina la consulta con una o varias subconsultas mediante UNION, EXCEPTo operadores INTERSECT.

• TABLESAMPLE

  Reduce el tamaño del conjunto de resultados mediante el muestreo de una fracción de las filas.

• PIVOT

  Se usa para la perspectiva de datos. Puede obtener los valores agregados en función de valores de columna específicos. Consulte PIVOT para obtener más información.

• UNPIVOT

  Se usa para la perspectiva de datos. Puede dividir varios grupos de columnas en filas. Consulte UNPIVOT para obtener más información.

Ejemplos

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

Artículos relacionados

• Cláusula GROUP BY
• JOIN
• Cláusula LIMIT
• Cláusula OFFSET
• Cláusula ORDER BY
• Cláusula PIVOT
• Operadores de conjuntos
• Referencia de tabla
• Cláusula TABLESAMPLE
• Cláusula UNPIVOT
• Cláusula WHERE
• Sintaxis de canalización de SQL
• Consulta
• Cláusula SELECT