Operazione con pipe

Si applica a: contrassegnato come sì Databricks SQL Databricks Runtime 16.2 e versioni successive

Elabora il risultato della query precedente utilizzando un'operazione concatenata.

Sintassi

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

Parametri

SELECT clausola

Raccoglie le colonne da restituire dalla query, compresa l'esecuzione delle espressioni e la deduplicazione.

L'elenco di colonne non deve contenere funzioni di aggregazione. Usare l'operazione AGGREGATE a tale scopo.
ESTENDERE

Aggiunge nuove colonne all'elenco di selezione della query.
- espressione
  
  Combinazione di uno o più valori, operatori e funzioni SQL che restituiscono un valore.
  
  expression può contenere riferimenti alle colonne nell'elenco di selezione della query, nonché ai precedenti column_alias in questa clausola EXTEND.
- column_alias
  
  Identificatore di colonna facoltativo che denomina il risultato dell'espressione. Se non viene fornito alcun column_alias, Azure Databricks ne deriva uno.
SET

Sostituisce le colonne esistenti nell'elenco di selezione della query con nuovi valori.

L'operazione viene eseguita nell'ordine di apparizione nella clausola SET. Il risultato di qualsiasi espressione può mostrare le colonne aggiornate da espressioni precedenti.
- nome_colonna
  
  Nome della colonna da aggiornare. Se la colonna non esiste, Azure Databricks genera un errore UNRESOLVED_COLUMN.
- di espressione
  
  Combinazione di uno o più valori, operatori e funzioni SQL che restituiscono un valore.
DROP column_name [, ...]

Rimuove le colonne dall'elenco di selezione della query.

Se la colonna non esiste, Azure Databricks genera un errore UNRESOLVED_COLUMN.
as table_alias

Assegna un nome al risultato della query.
WHERE

Filtra il risultato della query in base ai predicati forniti.
LIMIT

Limita il numero massimo di righe che possono essere restituite dalla query. Questa clausola segue in genere un ORDER BY per produrre un risultato deterministico.
OFFSET

Salta un certo numero di righe tra quelle restituite dalla query. Questa clausola viene in genere usata insieme dalla pagina LIMIT alla pagina di attraverso un set di risultati e ORDER BY per produrre un risultato deterministico.

Nota

Durante la paginazione di un set di risultati con LIMIT e OFFSET, tutte le righe vengono elaborate, incluse quelle ignorate. Tuttavia, solo il subset specificato di righe viene restituito nel set di risultati. L'impaginazione con questa tecnica non è consigliata per le query a elevato utilizzo di risorse.
aggregazione

Aggrega il set di risultati della query in base alle espressioni fornite e alle espressioni di raggruppamento facoltative.

Questa operazione produce un set di risultati in cui le colonne di raggruppamento vengono visualizzate prima delle colonne aggregate.
- aggregato
  
  Specifica le espressioni da aggregare.
  - aggregate_expr
    
    Espressione contenente una o più funzioni di aggregazione. Per altre informazioni, vedere GROUP BY.
- GROUP BY
  
  Specifica le espressioni in base alle quali vengono raggruppate le righe. Se non specificato, tutte le righe vengono considerate come un singolo gruppo.
  - espressione_di_raggruppamento
    
    Espressione che identifica le colonne di raggruppamento. Per altre informazioni, vedere GROUP BY.
    
    A differenza di una clausola GROUP BY generica, un valore numerico integrale identifica una colonna nella query che fornisce l'input e non il set di risultati generato.
- column_alias
  
  Identificatore di colonna facoltativo che denomina il risultato dell'espressione. Se non viene fornito alcun column_alias, Azure Databricks ne deriva uno.
JOIN

Combina due o più relazioni utilizzando un join. Per altre informazioni, vedere JOIN.
ORDER BY

Ordina le righe del set di risultati della query. Le righe di output vengono ordinate tra le partizioni. Questo parametro è mutuamente esclusivo con SORT BY, CLUSTER BYe DISTRIBUTE BY e non può essere specificato insieme.
operatore_di_impostazione

Combina la query con una o più sottoquery, usando gli operatori UNION, EXCEPTo INTERSECT.
TABLESAMPLE

Riduce le dimensioni del set di risultati eseguendo solo il campionamento di una frazione delle righe.
PIVOT

Utilizzato per la visione dei dati. È possibile ottenere i valori aggregati in base a valori di colonna specifici. Per altre informazioni, vedere PIVOT.
UNPIVOT

Utilizzato per la visione dei dati. È possibile suddividere più gruppi di colonne in righe. Per altre informazioni, vedere UNPIVOT.

Esempi

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

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-03-12

Condividi tramite

Operazione con pipe

Sintassi

Parametri

Esempi

Articoli correlati

Commenti e suggerimenti

Risorse aggiuntive