Questa pagina è stata tradotta dall'API Cloud Translation.

Funzioni, operatori e condizionali

Questo argomento è una raccolta di funzioni, operatori ed espressioni condizionali.

Per saperne di più su come chiamare le funzioni, sulle regole di chiamata funzione, sul prefisso SAFE e su tipi speciali di argomenti, consulta la sezione Chiamate di funzione.

OPERATORI E CONDIZIONI

Operatori

Gli operatori sono rappresentati da caratteri speciali o parole chiave. Non utilizzano la sintassi delle chiamate funzione. Un operatore manipola qualsiasi numero di input di dati, chiamati anche operandi, e restituisce un risultato.

Convenzioni comuni:

Se non diversamente specificato, tutti gli operatori restituiscono NULL quando uno degli operatori è NULL.
Se il risultato del calcolo ha superato il limite massimo, tutti gli operatori genereranno un errore.
Per tutte le operazioni in virgola mobile, +/-inf e NaN possono essere restituiti solo se uno degli operandi è +/-inf o NaN. in altri casi, viene restituito un errore.

Priorità dell'operatore

La seguente tabella elenca tutti gli operatori BigQuery dalla precedenza massima a quella minima, ovvero l'ordine in cui verranno valutati all'interno di una dichiarazione.

Ordine di precedenza	Operatore	Tipi di dati di input	Nome	Operatore
1	Operatore di accesso al campo	STRUTTURA JSON	Operatore di accesso al campo	Autorizzazione
	Operatore secondario Array	ARRAY	Posizione array. Deve essere utilizzato con OFFSET o decimal: consulta Array Functions .	Autorizzazione
	Operatore JSON iOS	JSON	Nome del campo o posizione dell'array in JSON.	Autorizzazione
2	+	Tutti i tipi numerici	Unary più	Unaario
	-	Tutti i tipi numerici	Meno unaario	Unaario
	~	Numero intero o BYTES	A bit non attivo	Unaario
3	*	Tutti i tipi numerici	Tavola pitagorica	Autorizzazione
	/	Tutti i tipi numerici	Divisione	Autorizzazione
	\|\|	STRING, BYTES o ARRAY<T>	Operatore di concatenazione	Autorizzazione
4	+	Tutti i tipi numerici, DATE con INT64 , INTERVAL	Aggiunta	Autorizzazione
	-	Tutti i tipi numerici, DATE con INT64 , INTERVAL	Sottrazione	Autorizzazione
5	<<	Numero intero o BYTES	Spostamento a sinistra a livello di bit	Autorizzazione
	>>	Numero intero o BYTES	Spostamento a destra a bit	Autorizzazione
6	&	Numero intero o BYTES	A livello di bit e	Autorizzazione
7	^	Numero intero o BYTES	bit xor	Autorizzazione
8	\|	Numero intero o BYTES	A livello di bit o	Autorizzazione
9 (operatori di confronto)	=	Qualsiasi tipo analogo. Consulta la pagina Tipi di dati per un elenco completo.	Uguale	Autorizzazione
	<	Qualsiasi tipo analogo. Consulta la pagina Tipi di dati per un elenco completo.	Minore di	Autorizzazione
	>	Qualsiasi tipo analogo. Consulta la pagina Tipi di dati per un elenco completo.	Maggiore di	Autorizzazione
	<=	Qualsiasi tipo analogo. Consulta la pagina Tipi di dati per un elenco completo.	Minore o uguale a	Autorizzazione
	>=	Qualsiasi tipo analogo. Consulta la pagina Tipi di dati per un elenco completo.	Maggiore o uguale a	Autorizzazione
	!=, <>	Qualsiasi tipo analogo. Consulta la pagina Tipi di dati per un elenco completo.	Diverso da	Autorizzazione
	[NOT] MI PIACI	STRING e byte	Il valore non corrisponde al pattern specificato	Autorizzazione
	[NOT] METTE	Tutti i tipi simili. Consulta la pagina Tipi di dati per un elenco completo.	Il valore non [è] compreso nell'intervallo specificato	Autorizzazione
	[NOT] IN	Tutti i tipi simili. Consulta la pagina Tipi di dati per un elenco completo.	Il valore [non] è nell'insieme dei valori specificati	Autorizzazione
	È [NOT] `NULL`	Tutti	Il valore è [not] `NULL`	Unaario
	IS [NOT] VERO	BOOL	Il valore è [not] TRUE.	Unaario
	IS [NOT] FALSO	BOOL	Il valore è [not] FALSE.	Unaario
10	NOT	BOOL	Logica NOT	Unaario
11	AND	BOOL	E logico	Autorizzazione
12	OPPURE	BOOL	O logico	Autorizzazione

Gli operatori con la stessa precedenza sono associativi. Ciò significa che questi operatori vengono raggruppati assieme a partire da sinistra e spostandosi verso destra. Ad esempio, l'espressione:

x AND y AND z

viene interpretato come

( ( x AND y ) AND z )

L'espressione:

x * y / z

viene interpretato come:

( ( x * y ) / z )

Tutti gli operatori di confronto hanno la stessa priorità, ma gli operatori di confronto non sono associativi. Pertanto, per risolvere l'ambiguità sono necessarie delle parentesi. Ad esempio:

(x < y) IS FALSE

Operatore di accesso al campo

expression.fieldname[. ...]

Descrizione

Visualizza il valore di un campo. In alternativa noto come operatore con punto. Può essere utilizzato per accedere a campi nidificati. Ad esempio, expression.fieldname1.fieldname2.

Tipi di input

STRUCT
JSON

Tipo di reso

Per STRUCT: tipo di dati SQL di fieldname. Se un campo non viene trovato, viene generato un errore.
Per JSON: JSON. Se un campo non viene trovato in un valore JSON, viene restituito un NULL SQL.

Esempio

Nell'esempio seguente, l'espressione è t.customer e le operazioni di accesso al campo sono .address e .country. Un'operazione è un'applicazione di un operatore (.) a operandi specifici (in questo caso, address e country o, più precisamente, t.customer e address, per la prima operazione, e t.customer.address e country per la seconda operazione).

WITH orders AS (
  SELECT STRUCT(STRUCT('Yonge Street' AS street, 'Canada' AS country) AS address) AS customer
)
SELECT t.customer.address.country FROM orders AS t;

+---------+
| country |
+---------+
| Canada  |
+---------+

Operatore secondario Array

array_expression[array_subscript_specifier]

array_subscript_specifier:
  position_keyword(index)

position_keyword:
  { OFFSET | SAFE_OFFSET | ORDINAL | SAFE_ORDINAL }

Descrizione

Visualizza un valore da un array in una posizione specifica.

Tipi di input

array_expression: l'array di input.
position_keyword: dove deve iniziare l'indice dell'array e come vengono gestiti gli indici fuori intervallo. Le opzioni disponibili sono:
- OFFSET: l'indice inizia da zero. Restituisce un errore se l'indice non rientra nell'intervallo.
- SAFE_OFFSET: l'indice inizia da zero. Restituisce NULL se l'indice non è compreso nell'intervallo.
- ORDINAL: l'indice inizia da uno. Restituisce un errore se l'indice non rientra nell'intervallo.
- SAFE_ORDINAL: l'indice inizia da uno. Restituisce NULL se l'indice non è compreso nell'intervallo.
index: un numero intero che rappresenta una posizione specifica nell'array.

Tipo di reso

T dove array_expression è ARRAY<T>.

Esempi

In questo esempio, l'operatore pedice array viene utilizzato per restituire valori in località specifiche in item_array. Questo esempio mostra anche cosa succede quando fai riferimento a un indice (6) in un array fuori intervallo. Se è incluso il prefisso SAFE, viene restituito NULL, altrimenti viene generato un errore.

WITH Items AS (SELECT ["coffee", "tea", "milk"] AS item_array)
SELECT
  item_array,
  item_array[OFFSET(1)] AS item_offset,
  item_array[ORDINAL(1)] AS item_ordinal,
  item_array[SAFE_OFFSET(6)] AS item_safe_offset,
FROM Items

+----------------------------------+--------------+--------------+------------------+
| item_array                       | item_offset  | item_ordinal | item_safe_offset |
+----------------------------------+--------------+--------------+------------------+
| [coffee, tea, milk]              | tea          | coffee       | NULL             |
+----------------------------------+--------------+--------------+------------------+

Nel seguente esempio, quando fai riferimento a un indice in un array fuori intervallo e il prefisso SAFE non viene incluso, viene generato un errore.

WITH Items AS (SELECT ["coffee", "tea", "milk"] AS item_array)
SELECT
  item_array[OFFSET(6)] AS item_offset
FROM Items

-- Error. OFFSET(6) is out of range.

Operatore JSON iOS

json_expression[array_element_id]

json_expression[field_name]

Descrizione

Visualizza il valore di un elemento o di un campo di un'espressione JSON. Può essere utilizzato per accedere a dati nidificati.

Tipi di input

JSON expression: l'espressione JSON che contiene un elemento o un campo array da restituire.
[array_element_id]: un'espressione INT64 che rappresenta un indice in base zero nell'array. Se viene inserito un valore negativo, se il valore è maggiore o uguale alle dimensioni dell'array o se l'espressione JSON non rappresenta un array JSON, viene restituito un valore NULL di SQL.
[field_name]: un'espressione STRING che rappresenta il nome di un campo in JSON. Se il nome del campo non viene trovato o se l'espressione JSON non è un oggetto JSON, viene restituito un NULL SQL.

Tipo di reso

JSON

Esempio

Nel seguente esempio:

json_value è un'espressione JSON.
.class è un accesso al campo JSON.
.students è un accesso al campo JSON.
[0] è un'espressione apice JSON con un offset dell'elemento che accede all'elemento zero di un array nel valore JSON.
['name'] è un'espressione JSON di un apice con un nome del campo che accede a un campo.

SELECT json_value.class.students[0]['name'] AS first_student
FROM
  UNNEST(
    [
      JSON '{"class" : {"students" : [{"name" : "Jane"}]}}',
      JSON '{"class" : {"students" : []}}',
      JSON '{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'])
    AS json_value;

+-----------------+
| first_student   |
+-----------------+
| "Jane"          |
| NULL            |
| "John"          |
+-----------------+

Operatori aritmetici

Tutti gli operatori aritmetici accettano l'input di tipo numerico T, mentre il tipo di risultato ha il tipo T, se non diversamente indicato nella seguente descrizione:

Nome	Syntax
Aggiunta	X + Y
Sottrazione	X - Y
Tavola pitagorica	X * Y
Divisione	X / Y
Unary Plus	+ X
Meno unaario	- X

NOTA: le operazioni di divisione per zero restituiscono un errore. Per restituire un risultato diverso, considera le funzioni IEEE_DIVIDE o SAFE_DIVIDE.

Tipi di risultati per aggiunta, sottrazione e moltiplicazione:

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
INT64	INT64	NUMERICO	BIGNUMERICA	FLOAT64
NUMERICO	NUMERICO	NUMERICO	BIGNUMERICO	FLOAT64
BIGNUMERICA	BIGNUMERICA	BIGNUMERICA	BIGNUMERICA	FLOAT64
FLOAT64	FLOAT64	FLOAT64	FLOAT64	FLOAT64

Tipi di risultati per la divisione:

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
INT64	FLOAT64	NUMERICO	BIGNUMERICA	FLOAT64
NUMERICO	NUMERICO	NUMERICO	BIGNUMERICA	FLOAT64
BIGNUMERICA	BIGNUMERICA	BIGNUMERICO	BIGNUMERICA	FLOAT64
FLOAT64	FLOAT64	FLOAT64	FLOAT64	FLOAT64

Tipi di risultati per Unary Plus:

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
USCITA	INT64	NUMERICO	BIGNUMERICA	FLOAT64

Tipi di risultati per Unario meno:

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
USCITA	INT64	NUMERICO	BIGNUMERICA	FLOAT64

Operatori di data aritmetica

Gli operatori '+' e '-' possono essere utilizzati per operazioni aritmetiche nelle date.

date_expression + int64_expression
int64_expression + date_expression
date_expression - int64_expression

Descrizione

Aggiunge o sottrae int64_expression giorni da o verso date_expression. Equivale alle funzioni DATE_ADD o DATE_SUB, quando l'intervallo è espresso in giorni.

Tipo di dati da restituire

DATA

Esempio

SELECT DATE "2020-09-22" + 1 AS day_later, DATE "2020-09-22" - 7 AS week_ago

+------------+------------+
| day_later  | week_ago   |
+------------+------------+
| 2020-09-23 | 2020-09-15 |
+------------+------------+

Sottrazione data

date_expression - date_expression
timestamp_expression - timestamp_expression
datetime_expression - datetime_expression

Descrizione

Calcola come differenza l'intervallo tra due valori di data e ora.

Tipo di dati da restituire

INTERVALLO

Esempio

SELECT
  DATE "2021-05-20" - DATE "2020-04-19" AS date_diff,
  TIMESTAMP "2021-06-01 12:34:56.789" - TIMESTAMP "2021-05-31 00:00:00" AS time_diff

+-------------------+------------------------+
| date_diff         | time_diff              |
+-------------------+------------------------+
| 0-0 396 0:0:0     | 0-0 0 36:34:56.789     |
+-------------------+------------------------+

Operatori aritmetici a intervalli

Addizione e sottrazione

date_expression + interval_expression = DATETIME
date_expression - interval_expression = DATETIME
timestamp_expression + interval_expression = TIMESTAMP
timestamp_expression - interval_expression = TIMESTAMP
datetime_expression + interval_expression = DATETIME
datetime_expression - interval_expression = DATETIME

Descrizione

Aggiunge un intervallo a un valore di data/ora o sottrae un intervallo da un valore di data/ora. Esempio

SELECT
  DATE "2021-04-20" + INTERVAL 25 HOUR AS date_plus,
  TIMESTAMP "2021-05-02 00:01:02.345" - INTERVAL 10 SECOND AS time_minus;

+-------------------------+--------------------------------+
| date_plus               | time_minus                     |
+-------------------------+--------------------------------+
| 2021-04-21 01:00:00     | 2021-05-02 00:00:52.345+00     |
+-------------------------+--------------------------------+

Moltiplicazione e divisione

interval_expression * integer_expression = INTERVAL
interval_expression / integer_expression = INTERVAL

Descrizione

Moltiplica o divide un valore intervallo per un numero intero.

Esempio

SELECT
  INTERVAL '1:2:3' HOUR TO SECOND * 10 AS mul1,
  INTERVAL 35 SECOND * 4 AS mul2,
  INTERVAL 10 YEAR / 3 AS div1,
  INTERVAL 1 MONTH / 12 AS div2

+----------------+--------------+-------------+--------------+
| mul1           | mul2         | div1        | div2         |
+----------------+--------------+-------------+--------------+
| 0-0 0 10:20:30 | 0-0 0 0:2:20 | 3-4 0 0:0:0 | 0-0 2 12:0:0 |
+----------------+--------------+-------------+--------------+

Operatori bit per bit

Tutti gli operatori bit per bit restituiscono lo stesso tipo e la stessa lunghezza del primo operando.

Nome	Syntax	Tipo di dati di input	Descrizione
A bit non attivo	~ X	Numero intero o BYTES	Esegue una negazione logica su ogni bit, formando il valore del valore binario specificato.
A livello di bit o	X \| Y	X: numero intero o BYTE Y: stesso tipo di X	Prende due pattern di uguale lunghezza ed esegue l'operazione logica inclusiva O su ogni coppia dei bit corrispondenti. Questo operatore genera un errore se X e Y sono BYTES di lunghezze diverse.
bit xor	X ^ Y	X: numero intero o BYTE Y: stesso tipo di X	Prende due pattern di uguale lunghezza ed esegue l'operazione logica esclusiva OR su ogni coppia dei bit corrispondenti. Questo operatore genera un errore se X e Y sono BYTES di lunghezze diverse.
A livello di bit e	X & Y	X: numero intero o BYTE Y: stesso tipo di X	Prende due pattern di uguale lunghezza ed esegue l'operazione logica E su ogni coppia dei bit corrispondenti. Questo operatore genera un errore se X e Y sono BYTES di lunghezze diverse.
Maiusc a sinistra	X <Y	X: Intero o BYTES Y: INT64	Sposta il primo operando X a sinistra. Questo operatore restituisce 0 o una sequenza di byte di b'\x00' se il secondo operando Y è maggiore o uguale alla lunghezza del bit del primo operando X (ad esempio, 64 se X ha il tipo INT64). Se Y è negativo, questo operatore genera un errore.
Maiusc a destra	X >>Y	X: Intero o BYTES Y: INT64	Sposta il primo operando X a destra. Questo operatore non esegue l'estensione di bit di firma con un tipo firmato (ovvero riempie i bit vacanti sulla sinistra con 0). Questo operatore restituisce 0 o una sequenza di byte di b'\x00' se il secondo operando Y è maggiore o uguale alla lunghezza del bit del primo operando X (ad esempio, 64 se X ha il tipo INT64). Se Y è negativo, questo operatore genera un errore.

Operatori logici

BigQuery supporta gli operatori logici AND, OR e NOT. Gli operatori logici consentono solo l'input BOOL o NULL e utilizzano la logica a tre valori per produrre un risultato. Il risultato può essere TRUE, FALSE o NULL:

x	a	x AND y	x O y
VERO	VERO	VERO	VERO
VERO	FALSO	FALSO	VERO
VERO	NULL	NULL	VERO
FALSO	VERO	FALSO	VERO
FALSO	FALSO	FALSO	FALSO
FALSO	NULL	FALSO	NULL
NULL	VERO	NULL	VERO
NULL	FALSO	FALSO	NULL
NULL	NULL	NULL	NULL

x	NON x
VERO	FALSO
FALSO	VERO
NULL	NULL

Esempi

Gli esempi in questa sezione fanno riferimento a una tabella denominata entry_table:

+-------+
| entry |
+-------+
| a     |
| b     |
| c     |
| NULL  |
+-------+

SELECT 'a' FROM entry_table WHERE entry = 'a'

-- a => 'a' = 'a' => TRUE
-- b => 'b' = 'a' => FALSE
-- NULL => NULL = 'a' => NULL

+-------+
| entry |
+-------+
| a     |
+-------+

SELECT entry FROM entry_table WHERE NOT (entry = 'a')

-- a => NOT('a' = 'a') => NOT(TRUE) => FALSE
-- b => NOT('b' = 'a') => NOT(FALSE) => TRUE
-- NULL => NOT(NULL = 'a') => NOT(NULL) => NULL

+-------+
| entry |
+-------+
| b     |
| c     |
+-------+

SELECT entry FROM entry_table WHERE entry IS NULL

-- a => 'a' IS NULL => FALSE
-- b => 'b' IS NULL => FALSE
-- NULL => NULL IS NULL => TRUE

+-------+
| entry |
+-------+
| NULL  |
+-------+

Operatori di confronto

I confronti restituiscono sempre BOOL. In genere i confronti richiedono che entrambi gli operandi siano dello stesso tipo. Se gli operandi sono di tipo diverso e se BigQuery può convertire i valori di tali tipi in un tipo comune senza perdita di precisione, in genere BigQuery li coerisce a quel tipo comune per il confronto; BigQuery in genere coerisce i valori letterali al tipo di valore non letterale, laddove presente. Tipi di dati simili vengono definiti in Tipi di dati.

Gli STRUCT supportano solo quattro operatori di confronto: uguale a (=), non uguale a (!= e <>) e IN.

Per il confronto di questi tipi di dati si applicano le seguenti regole:

FLOAT64: Tutti i confronti con NaN restituiscono FALSE, tranne != e <>, che restituiscono TRUE.
BOOL: FALSE è inferiore a TRUE.
STRINGA: le stringhe vengono confrontate per punto di codice per codice, il che significa che è garantito che le stringhe canoniche equivalenti vengano confrontate solo se sono state normalizzate per prime.
NULL: la convenzione vale qui: qualsiasi operazione con un input NULL restituisce NULL.

Nome	Syntax	Descrizione
Minore di	X < Y	Restituisce TRUE se X è minore di Y. Questo operatore supporta l'indicazione della comparazione.
Minore o uguale a	X <= Y	Restituisce TRUE se X è minore o uguale a Y. Questo operatore supporta l'indicazione della comparazione.
Maggiore di	X > Y	Restituisce TRUE se X è maggiore di Y. Questo operatore supporta l'indicazione della comparazione.
Maggiore o uguale a	X >= Y	Restituisce TRUE se X è maggiore o uguale a Y. Questo operatore supporta l'indicazione della comparazione.
Uguale	X = Y	Restituisce TRUE se X è uguale a Y. Questo operatore supporta l'indicazione della comparazione.
Diverso da	X != Y X <> Y	Restituisce TRUE se X non è uguale a Y. Questo operatore supporta l'indicazione della comparazione.
TRA	X [NOT] TRA Y E Z	Restituisce TRUE se X non [è] compreso nell'intervallo specificato. Il risultato di "X BETWEEN Y AND Z" equivale a "Y <= X AND X <= Z" ma X viene valutato una sola volta nel primo. Questo operatore supporta l'indicazione della comparazione.
MI PIACI	X [NON] MI PIA	Verifica se il STRING nell'operando X corrisponde a un pattern specificato dal secondo operando Y. Le espressioni possono contenere i seguenti caratteri: Un simbolo percentuale "%" corrisponde a qualsiasi numero di caratteri o byte Un trattino basso "_" corrisponde a un singolo carattere o byte Puoi sfuggire "\", "_" o "%" usando due barre rovesciate. Ad esempio, `"\\%"`. Se utilizzi stringhe non elaborate, è necessaria una sola barra rovesciata. Ad esempio, `r"\%"`.
IN	Multiplo - vedi sotto	Restituisce FALSE se l'operando destro è vuoto. Restituisce `NULL` se l'operando sinistro è `NULL`. Restituisce TRUE o `NULL`, mai FALSE, se l'operando destro contiene `NULL`. Gli argomenti su entrambi i lati di IN sono espressioni generali. Nessuno degli operanti è obbligatorio come letterale, sebbene l'utilizzo di un valore letterale a destra sia il più comune. X viene valutato una sola volta. In genere questo operatore supporta l'impostazione di collatura.

Quando si verificano valori per i tipi di dati STRUCT in termini di uguaglianza, è possibile che uno o più campi siano NULL. In questi casi:

Se tutti i valori dei campi non NULL sono uguali, il confronto restituisce NULL.
Se valori di campo non NULL sono diversi, il confronto restituisce false.

La seguente tabella mostra come vengono confrontati i tipi di dati STRUCT se includono campi per i quali i valori sono considerati NULL.

Struttura 1	Struttura 2	Struct1 = Struct2
`STRUCT(1, NULL)`	`STRUCT(1, NULL)`	`NULL`
`STRUCT(1, NULL)`	`STRUCT(2, NULL)`	`FALSE`
`STRUCT(1,2)`	`STRUCT(1, NULL)`	`NULL`

Operatore EXISTS

EXISTS ( subquery )

Descrizione

Restituisce TRUE se la sottoquery produce una o più righe. Restituisce FALSE se la sottoquery produce zero righe. Non restituisce mai NULL. Per scoprire di più su come utilizzare una sottoquery con EXISTS, consulta la sezione Subquery EXISTS.

Esempi

In questo esempio, l'operatore EXISTS restituisce FALSE perché non sono presenti righe in Words in cui la direzione è south:

WITH Words AS (
  SELECT 'Intend' as value, 'east' as direction UNION ALL
  SELECT 'Secure', 'north' UNION ALL
  SELECT 'Clarity', 'west'
 )
SELECT EXISTS ( SELECT value FROM Words WHERE direction = 'south' ) as result;

+--------+
| result |
+--------+
| FALSE  |
+--------+

Operatore IN

La sintassi dell'operatore IN supporta la seguente sintassi:

search_value [NOT] IN value_set

value_set:
  {
    (expression[, ...])
    | (subquery)
    | UNNEST(array_expression)
  }

Descrizione

Verifica la presenza di un valore uguale in un insieme di valori. Vengono applicate regole semantiche, ma in generale IN restituisce TRUE se viene trovato un valore uguale, FALSE se viene escluso un valore uguale, altrimenti NULL. NOT IN restituisce FALSE se viene trovato un valore uguale, TRUE se viene escluso un valore uguale, altrimenti è NULL.

search_value: l'espressione che viene confrontata con un insieme di valori.
value_set: uno o più valori da confrontare con un valore di ricerca.
- (expression[, ...]): un elenco di espressioni.
- (subquery): una query secondaria che restituisce una singola colonna. I valori della colonna rappresentano l'insieme di valori. Se non vengono generate righe, l'insieme di valori è vuoto.
- UNNEST(array_expression): un operatore UNNEST che restituisce una colonna di valori da un'espressione array. Equivale a:
```
IN (SELECT element FROM UNNEST(array_expression) AS element)
```

Regole semantiche

Quando utilizzi l'operatore IN, viene applicata la seguente semantica nel seguente ordine:

Restituisce FALSE se value_set è vuoto.
Restituisce NULL se search_value è NULL.
Restituisce TRUE se value_set contiene un valore uguale a search_value.
Restituisce NULL se value_set contiene un NULL.
Restituisce FALSE.

Quando utilizzi l'operatore NOT IN, viene applicata la seguente semantica nel seguente ordine:

Restituisce TRUE se value_set è vuoto.
Restituisce NULL se search_value è NULL.
Restituisce FALSE se value_set contiene un valore uguale a search_value.
Restituisce NULL se value_set contiene un NULL.
Restituisce TRUE.

Generalmente questo operatore supporta la collatura, tuttavia, x [NOT] IN UNNEST non è supportato.

La semantica di:

x IN (y, z, ...)

sono definite come equivalenti a:

(x = y) OR (x = z) OR ...

mentre le forme di sottoquery e array sono definite in modo analogo.

x NOT IN ...

equivale a:

NOT(x IN ...)

Il modulo UNNEST tratta una scansione di array come UNNEST nella clausola FROM:

x [NOT] IN UNNEST(<array expression>)

Questo modulo viene spesso utilizzato con i parametri ARRAY. Ad esempio:

x IN UNNEST(@array_parameter)

Per scoprire di più su come utilizzare questa sintassi, consulta l'argomento Array.

È possibile utilizzare IN con le chiavi composte da più parti utilizzando la sintassi del costruttore struct. Ad esempio:

(Key1, Key2) IN ( (12,34), (56,78) )
(Key1, Key2) IN ( SELECT (table.a, table.b) FROM table )

Per ulteriori informazioni, consulta il Tipo di struttura.

Tipo di dati da restituire

BOOL

Esempi

Puoi utilizzare queste clausole WITH per emulare le tabelle temporanee per Words e Items negli esempi seguenti:

WITH Words AS (
  SELECT 'Intend' as value UNION ALL
  SELECT 'Secure' UNION ALL
  SELECT 'Clarity' UNION ALL
  SELECT 'Peace' UNION ALL
  SELECT 'Intend'
 )
SELECT * FROM Words;

+----------+
| value    |
+----------+
| Intend   |
| Secure   |
| Clarity  |
| Peace    |
| Intend   |
+----------+

WITH
  Items AS (
    SELECT STRUCT('blue' AS color, 'round' AS shape) AS info UNION ALL
    SELECT STRUCT('blue', 'square') UNION ALL
    SELECT STRUCT('red', 'round')
  )
SELECT * FROM Items;

+----------------------------+
| info                       |
+----------------------------+
| {blue color, round shape}  |
| {blue color, square shape} |
| {red color, round shape}   |
+----------------------------+

Esempio con IN e un'espressione:

SELECT * FROM Words WHERE value IN ('Intend', 'Secure');

+----------+
| value    |
+----------+
| Intend   |
| Secure   |
| Intend   |
+----------+

Esempio con NOT IN e un'espressione:

SELECT * FROM Words WHERE value NOT IN ('Intend');

+----------+
| value    |
+----------+
| Secure   |
| Clarity  |
| Peace    |
+----------+

Esempio con IN, una sottoquery scalare e un'espressione:

SELECT * FROM Words WHERE value IN ((SELECT 'Intend'), 'Clarity');

+----------+
| value    |
+----------+
| Intend   |
| Clarity  |
| Intend   |
+----------+

Esempio con IN e un'operazione UNNEST:

SELECT * FROM Words WHERE value IN UNNEST(['Secure', 'Clarity']);

+----------+
| value    |
+----------+
| Secure   |
| Clarity  |
+----------+

Esempio con IN e STRUCT:

SELECT
  (SELECT AS STRUCT Items.info) as item
FROM
  Items
WHERE (info.shape, info.color) IN (('round', 'blue'));

+------------------------------------+
| item                               |
+------------------------------------+
| { {blue color, round shape} info } |
+------------------------------------+

Operatori IS

Gli operatori IS restituiscono TRUE o FALSE per la condizione che stanno testando. Non restituiscono mai NULL, anche per gli input NULL, a differenza delle funzioni IS_INF e IS_NAN definite nelle Funzioni matematiche. Se è presente NOT, il valore BOOL di output viene invertito.

Sintassi delle funzioni	Tipo di dati di input	Tipo di dati dei risultati	Descrizione
X IS TRUE	BOOL	BOOL	Restituisce un valore TRUE se X restituisce TRUE. In caso contrario, restituisce FALSE.
X IS NOT TRUE	BOOL	BOOL	Restituisce un valore FALSE se X restituisce TRUE. Altrimenti, restituisce TRUE.
X IS FALSE	BOOL	BOOL	Restituisce un valore TRUE se X restituisce FALSE. In caso contrario, restituisce FALSE.
X IS NOT FALSE	BOOL	BOOL	Restituisce FALSE se X restituisce FALSE. Altrimenti, restituisce TRUE.
X IS NULL	Qualsiasi tipo di valore	BOOL	Restituisce un valore TRUE se X restituisce `NULL`. In caso contrario, restituisce FALSE.
X IS NOT NULL	Qualsiasi tipo di valore	BOOL	Restituisce un valore FALSE se X restituisce `NULL`. In caso contrario, restituisce TRUE.
X IS UNKNOWN	BOOL	BOOL	Restituisce un valore TRUE se X restituisce `NULL`. In caso contrario, restituisce FALSE.
X IS NOT UNKNOWN	BOOL	BOOL	Restituisce un valore FALSE se X restituisce `NULL`. Altrimenti, restituisce TRUE.

Operatore IS DISTINCT FROM

expression_1 IS [NOT] DISTINCT FROM expression_2

Descrizione

IS DISTINCT FROM restituisce TRUE se i valori di input sono considerati distinti tra loro dalle clausole DISTINCT e GROUP BY. In caso contrario, restituisce FALSE.

a IS DISTINCT FROM b essere TRUE equivale a:

SELECT COUNT(DISTINCT x) FROM UNNEST([a,b]) x restituisce 2.
SELECT * FROM UNNEST([a,b]) x GROUP BY x restituisce 2 righe.

a IS DISTINCT FROM b equivale a NOT (a = b), ad eccezione dei seguenti casi:

Questo operatore non restituisce mai NULL, pertanto i valori NULL vengono considerati diversi dai valori NULL, non da altri valori NULL.
I valori NaN sono considerati distinti dai valori non NaN, ma non altri valori NaN.

Tipi di input

expression_1: il primo valore da confrontare. Può essere un tipo di dati raggruppabile, NULL o NaN.
expression_2: il secondo valore da confrontare. Può essere un tipo di dati raggruppabile, NULL o NaN.
NOT: se presente, il valore dell'output BOOL è invertito.

Tipo di reso

BOOL

Esempi

Ecco TRUE di ritorno:

SELECT 1 IS DISTINCT FROM 2

SELECT 1 IS DISTINCT FROM NULL

SELECT 1 IS NOT DISTINCT FROM 1

SELECT NULL IS NOT DISTINCT FROM NULL

Ecco FALSE di ritorno:

SELECT NULL IS DISTINCT FROM NULL

SELECT 1 IS DISTINCT FROM 1

SELECT 1 IS NOT DISTINCT FROM 2

SELECT 1 IS NOT DISTINCT FROM NULL

Operatore di concatenazione

L'operatore di concatenazione combina più valori in uno.

Sintassi delle funzioni	Tipo di dati di input	Tipo di dati dei risultati
STRING \|\| STRING [ \|\| ... ]	STRINGA	STRINGA
BYTES \|\| BYTES [ \|\| ... ]	BIT	STRINGA
ARRAY<T> \|\| ARRAY<T> [ \|\| ... ]	ARRAY<T>	ARRAY<T>

Espressioni condizionali

Le espressioni condizionali impongono vincoli all'ordine di valutazione dei loro input. In sostanza, vengono valutati da sinistra a destra, con cortocircuito, e solo il valore di output scelto. Al contrario, tutti gli input per le funzioni normali vengono valutati prima di chiamare la funzione. Il cortocircuito nelle espressioni condizionali può essere sfruttato per la gestione degli errori o l'ottimizzazione delle prestazioni.

Espr. CASE

CASE expr
  WHEN expr_to_match THEN result
  [ ... ]
  [ ELSE else_result ]
  END

Descrizione

Confronta expr con expr_to_match di ogni clausola WHEN successiva e restituisce il primo risultato in cui questo confronto restituisce true. Le WHEN clausole e else_result rimanenti non vengono valutate. Se il confronto expr = expr_to_match restituisce un valore false o NULL per tutte le clausole WHEN, restituisce else_result se presente; in caso contrario, restituisce NULL.

expr e expr_to_match possono essere di qualsiasi tipo. Devono essere implicitamente coercibili a un supertipo comune; i confronti tra uguaglianze vengono effettuati su valori coerciti. Potrebbero esistere più tipi result. Le espressioni result e else_result devono essere coerenti con un supertipo comune.

Questa espressione supporta l'opzione di specifica.

Tipo di dati da restituire

Supertipo di result[, ...] e else_result.

Esempio

WITH Numbers AS (
  SELECT 90 as A, 2 as B UNION ALL
  SELECT 50, 8 UNION ALL
  SELECT 60, 6 UNION ALL
  SELECT 50, 10
)
SELECT
  A,
  B,
  CASE A
    WHEN 90 THEN 'red'
    WHEN 50 THEN 'blue'
    ELSE 'green'
    END
    AS result
FROM Numbers

+------------------+
| A  | B  | result |
+------------------+
| 90 | 2  | red    |
| 50 | 8  | blue   |
| 60 | 6  | green  |
| 50 | 10 | blue   |
+------------------+

CASE

CASE
  WHEN condition THEN result
  [ ... ]
  [ ELSE else_result ]
  END

Descrizione

Valuta la condizione di ogni clausola WHEN successiva e restituisce il primo risultato in cui la condizione è true; eventuali clausole WHEN rimanenti e else_result non vengono valutate. Se tutte le condizioni sono false o NULL, restituisce else_result se presente; in caso contrario, restituisce NULL.

condition deve essere un'espressione booleana. Potrebbero esistere più tipi result. Le espressioni result e else_result devono essere implicitamente comprensibili a un supertipo comune.

Questa espressione supporta l'opzione di specifica.

Tipo di dati da restituire

Supertipo di result[, ...] e else_result.

Esempio

WITH Numbers AS (
  SELECT 90 as A, 2 as B UNION ALL
  SELECT 50, 6 UNION ALL
  SELECT 20, 10
)
SELECT
  A,
  B,
  CASE
    WHEN A > 60 THEN 'red'
    WHEN A > 30 THEN 'blue'
    ELSE 'green'
    END
    AS result
FROM Numbers

+------------------+
| A  | B  | result |
+------------------+
| 90 | 2  | red    |
| 50 | 6  | blue   |
| 20 | 10 | green  |
+------------------+

COALESCE

COALESCE(expr[, ...])

Descrizione

Restituisce il valore della prima espressione non null. Le espressioni rimanenti non vengono valutate. Un'espressione di input può essere di qualsiasi tipo. Potrebbero esserci più tipi di espressioni di input. Tutte le espressioni di input devono essere implicitamente comprensibili a un supertipo comune.

Tipo di dati da restituire

Supertipo di expr[, ...].

Esempi

SELECT COALESCE('A', 'B', 'C') as result

+--------+
| result |
+--------+
| A      |
+--------+

SELECT COALESCE(NULL, 'B', 'C') as result

+--------+
| result |
+--------+
| B      |
+--------+

SE

IF(expr, true_result, else_result)

Descrizione

Se expr è true, restituisce true_result, altrimenti restituisce else_result. else_result non è valutato se expr è true. true_result non viene valutato se expr è false o NULL.

expr deve essere un'espressione booleana. true_result e else_result devono essere coercibili a un supertipo comune.

Tipo di dati da restituire

Supertipo di true_result e else_result.

Esempio

WITH Numbers AS (
  SELECT 10 as A, 20 as B UNION ALL
  SELECT 50, 30 UNION ALL
  SELECT 60, 60
)
SELECT
  A,
  B,
  IF(A < B, 'true', 'false') AS result
FROM Numbers

+------------------+
| A  | B  | result |
+------------------+
| 10 | 20 | true   |
| 50 | 30 | false  |
| 60 | 60 | false  |
+------------------+

IFNULL

IFNULL(expr, null_result)

Descrizione

Se expr è NULL, restituisci null_result. Altrimenti, restituisci expr. Se expr non è NULL, null_result non viene valutato.

expr e null_result possono essere di qualsiasi tipo e devono essere implicitamente coercibili a un supertipo comune. Sinonimi per COALESCE(expr, null_result).

Tipo di dati da restituire

Supertipo di expr o null_result.

Esempi

SELECT IFNULL(NULL, 0) as result

+--------+
| result |
+--------+
| 0      |
+--------+

SELECT IFNULL(10, 0) as result

+--------+
| result |
+--------+
| 10     |
+--------+

NULLO

NULLIF(expr, expr_to_match)

Descrizione

Restituisce NULL se expr = expr_to_match è true, altrimenti restituisce expr.

expr e expr_to_match devono essere implicitamente comprensibili a un supertipo comune e devono essere paragonabili.

Questa espressione supporta l'opzione di specifica.

Tipo di dati da restituire

Supertipo di expr e expr_to_match.

Esempio

SELECT NULLIF(0, 0) as result

+--------+
| result |
+--------+
| NULL   |
+--------+

SELECT NULLIF(10, 0) as result

+--------+
| result |
+--------+
| 10     |
+--------+

FUNZIONI

Funzioni di aggregazione

In SQL standard di Google sono disponibili le seguenti funzioni aggregate generali. Per informazioni sulla sintassi per le chiamate di funzione aggregate, consulta Chiamate di funzione aggregate.

ANY_VALUE

ANY_VALUE(
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce expression per una riga scelta dal gruppo. La riga scelta non è deterministica, non casuale. Restituisce NULL quando l'input non produce righe. Restituisce NULL quando expression è NULL per tutte le righe del gruppo.

ANY_VALUE si comporta come se venisse specificato RESPECT NULLS; righe per cui expression è considerato NULL e possono essere selezionate.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipi di argomenti supportati

Qualsiasi

Tipi di dati restituiti

Corrisponde al tipo di dati di input.

Esempi

SELECT ANY_VALUE(fruit) as any_value
FROM UNNEST(["apple", "banana", "pear"]) as fruit;

+-----------+
| any_value |
+-----------+
| apple     |
+-----------+

SELECT
  fruit,
  ANY_VALUE(fruit) OVER (ORDER BY LENGTH(fruit) ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS any_value
FROM UNNEST(["apple", "banana", "pear"]) as fruit;

+--------+-----------+
| fruit  | any_value |
+--------+-----------+
| pear   | pear      |
| apple  | pear      |
| banana | apple     |
+--------+-----------+

ARRAY_AGG

ARRAY_AGG(
  [ DISTINCT ]
  expression
  [ { IGNORE | RESPECT } NULLS ]
  [ ORDER BY key [ { ASC | DESC } ] [, ... ] ]
  [ LIMIT n ]
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce un ARRAY di expression valori.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Viene generato un errore se un array nel risultato della query finale contiene un elemento NULL.

Tipi di argomenti supportati

Tutti i tipi di dati tranne ARRAY.

Tipi di dati restituiti

ARRAY

Se non ci sono righe di input, questa funzione restituisce NULL.

Esempi

SELECT ARRAY_AGG(x) AS array_agg FROM UNNEST([2, 1,-2, 3, -2, 1, 2]) AS x;

+-------------------------+
| array_agg               |
+-------------------------+
| [2, 1, -2, 3, -2, 1, 2] |
+-------------------------+

SELECT ARRAY_AGG(DISTINCT x) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+---------------+
| array_agg     |
+---------------+
| [2, 1, -2, 3] |
+---------------+

SELECT ARRAY_AGG(x IGNORE NULLS) AS array_agg
FROM UNNEST([NULL, 1, -2, 3, -2, 1, NULL]) AS x;

+-------------------+
| array_agg         |
+-------------------+
| [1, -2, 3, -2, 1] |
+-------------------+

SELECT ARRAY_AGG(x ORDER BY ABS(x)) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+-------------------------+
| array_agg               |
+-------------------------+
| [1, 1, 2, -2, -2, 2, 3] |
+-------------------------+

SELECT ARRAY_AGG(x LIMIT 5) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+-------------------+
| array_agg         |
+-------------------+
| [2, 1, -2, 3, -2] |
+-------------------+

WITH vals AS
  (
    SELECT 1 x UNION ALL
    SELECT -2 x UNION ALL
    SELECT 3 x UNION ALL
    SELECT -2 x UNION ALL
    SELECT 1 x
  )
SELECT ARRAY_AGG(DISTINCT x ORDER BY x) as array_agg
FROM vals;

+------------+
| array_agg  |
+------------+
| [-2, 1, 3] |
+------------+

WITH vals AS
  (
    SELECT 1 x, 'a' y UNION ALL
    SELECT 1 x, 'b' y UNION ALL
    SELECT 2 x, 'a' y UNION ALL
    SELECT 2 x, 'c' y
  )
SELECT x, ARRAY_AGG(y) as array_agg
FROM vals
GROUP BY x;

+---------------+
| x | array_agg |
+---------------+
| 1 | [a, b]    |
| 2 | [a, c]    |
+---------------+

SELECT
  x,
  ARRAY_AGG(x) OVER (ORDER BY ABS(x)) AS array_agg
FROM UNNEST([2, 1, -2, 3, -2, 1, 2]) AS x;

+----+-------------------------+
| x  | array_agg               |
+----+-------------------------+
| 1  | [1, 1]                  |
| 1  | [1, 1]                  |
| 2  | [1, 1, 2, -2, -2, 2]    |
| -2 | [1, 1, 2, -2, -2, 2]    |
| -2 | [1, 1, 2, -2, -2, 2]    |
| 2  | [1, 1, 2, -2, -2, 2]    |
| 3  | [1, 1, 2, -2, -2, 2, 3] |
+----+-------------------------+

ARRAY_CONCAT_AGG

ARRAY_CONCAT_AGG(
  expression
  [ ORDER BY key [ { ASC | DESC } ] [, ... ] ]
  [ LIMIT n ]
)

Descrizione

Concatena gli elementi di expression di tipo ARRAY, restituisce come risultato un singolo ARRAY. Questa funzione ignora gli array di input NULL, ma rispetta gli elementi NULL negli array di input non NULL (viene tuttavia generato un errore, se un array nel risultato della query finale contiene un elemento NULL).

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Tipi di argomenti supportati

ARRAY

Tipi di dati restituiti

ARRAY

Restituisce NULL se non sono presenti righe di input o expression restituisce NULL per tutte le righe.

Esempi

SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x)) AS array_concat_agg FROM (
  SELECT [NULL, 1, 2, 3, 4] AS x
  UNION ALL SELECT NULL
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+-----------------------------------+
| array_concat_agg                  |
+-----------------------------------+
| [NULL, 1, 2, 3, 4, 5, 6, 7, 8, 9] |
+-----------------------------------+

SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x ORDER BY ARRAY_LENGTH(x))) AS array_concat_agg FROM (
  SELECT [1, 2, 3, 4] AS x
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+-----------------------------------+
| array_concat_agg                  |
+-----------------------------------+
| [5, 6, 7, 8, 9, 1, 2, 3, 4]       |
+-----------------------------------+

SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x LIMIT 2)) AS array_concat_agg FROM (
  SELECT [1, 2, 3, 4] AS x
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+--------------------------+
| array_concat_agg         |
+--------------------------+
| [1, 2, 3, 4, 5, 6]       |
+--------------------------+

SELECT FORMAT("%T", ARRAY_CONCAT_AGG(x ORDER BY ARRAY_LENGTH(x) LIMIT 2)) AS array_concat_agg FROM (
  SELECT [1, 2, 3, 4] AS x
  UNION ALL SELECT [5, 6]
  UNION ALL SELECT [7, 8, 9]
);

+------------------+
| array_concat_agg |
+------------------+
| [5, 6, 7, 8, 9]  |
+------------------+

AVG

AVG(
  [ DISTINCT ]
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce la media dei valori di input non NULL oppure NaN se l'input contiene un elemento NaN.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipi di argomenti supportati

Qualsiasi tipo di input numerico, come INT64. Tieni presente che, per i tipi di input con virgola mobile, il risultato restituito non è deterministico, il che significa che potresti ricevere un risultato diverso ogni volta che utilizzi questa funzione.

Tipi di dati restituiti

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
USCITA	FLOAT64	NUMERICO	BIGNUMERICA	FLOAT64

Esempi

SELECT AVG(x) as avg
FROM UNNEST([0, 2, 4, 4, 5]) as x;

+-----+
| avg |
+-----+
| 3   |
+-----+

SELECT AVG(DISTINCT x) AS avg
FROM UNNEST([0, 2, 4, 4, 5]) AS x;

+------+
| avg  |
+------+
| 2.75 |
+------+

SELECT
  x,
  AVG(x) OVER (ORDER BY x ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS avg
FROM UNNEST([0, 2, NULL, 4, 4, 5]) AS x;

+------+------+
| x    | avg  |
+------+------+
| NULL | NULL |
| 0    | 0    |
| 2    | 1    |
| 4    | 3    |
| 4    | 4    |
| 5    | 4.5  |
+------+------+

BIT_E

BIT_AND(
  expression
)

Descrizione

Esegue un'operazione AND a livello di bit su expression e restituisce il risultato.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Tipi di argomenti supportati

INT64

Tipi di dati restituiti

INT64

Esempi

SELECT BIT_AND(x) as bit_and FROM UNNEST([0xF001, 0x00A1]) as x;

+---------+
| bit_and |
+---------+
| 1       |
+---------+

BIT_O

BIT_OR(
  expression
)

Descrizione

Esegue un'operazione OR a livello di bit su expression e restituisce il risultato.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Tipi di argomenti supportati

INT64

Tipi di dati restituiti

INT64

Esempi

SELECT BIT_OR(x) as bit_or FROM UNNEST([0xF001, 0x00A1]) as x;

+--------+
| bit_or |
+--------+
| 61601  |
+--------+

BIT_XOR

BIT_XOR(
  [ DISTINCT ]
  expression
)

Descrizione

Esegue un'operazione XOR a livello di bit su expression e restituisce il risultato.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Tipi di argomenti supportati

INT64

Tipi di dati restituiti

INT64

Esempi

SELECT BIT_XOR(x) AS bit_xor FROM UNNEST([5678, 1234]) AS x;

+---------+
| bit_xor |
+---------+
| 4860    |
+---------+

SELECT BIT_XOR(x) AS bit_xor FROM UNNEST([1234, 5678, 1234]) AS x;

+---------+
| bit_xor |
+---------+
| 5678    |
+---------+

SELECT BIT_XOR(DISTINCT x) AS bit_xor FROM UNNEST([1234, 5678, 1234]) AS x;

+---------+
| bit_xor |
+---------+
| 4860    |
+---------+

COUNT

COUNT(*)
[OVER over_clause]

COUNT(
  [ DISTINCT ]
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce il numero di righe nell'input.
Restituisce il numero di righe con expression valutato in qualsiasi valore diverso da NULL.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Questa funzione con DISTINCT supporta la specifica collation.

Tipi di argomenti supportati

expression può essere di qualsiasi tipo. Se DISTINCT è presente, expression può essere solo un tipo di dati raggruppabile.

Tipi di dati restituiti

INT64

Esempi

Puoi utilizzare la funzione COUNT per restituire il numero di righe di una tabella o il numero di valori distinti di un'espressione. Ad esempio:

SELECT
  COUNT(*) AS count_star,
  COUNT(DISTINCT x) AS count_dist_x
FROM UNNEST([1, 4, 4, 5]) AS x;

+------------+--------------+
| count_star | count_dist_x |
+------------+--------------+
| 4          | 3            |
+------------+--------------+

SELECT
  x,
  COUNT(*) OVER (PARTITION BY MOD(x, 3)) AS count_star,
  COUNT(DISTINCT x) OVER (PARTITION BY MOD(x, 3)) AS count_dist_x
FROM UNNEST([1, 4, 4, 5]) AS x;

+------+------------+--------------+
| x    | count_star | count_dist_x |
+------+------------+--------------+
| 1    | 3          | 2            |
| 4    | 3          | 2            |
| 4    | 3          | 2            |
| 5    | 1          | 1            |
+------+------------+--------------+

SELECT
  x,
  COUNT(*) OVER (PARTITION BY MOD(x, 3)) AS count_star,
  COUNT(x) OVER (PARTITION BY MOD(x, 3)) AS count_x
FROM UNNEST([1, 4, NULL, 4, 5]) AS x;

+------+------------+---------+
| x    | count_star | count_x |
+------+------------+---------+
| NULL | 1          | 0       |
| 1    | 3          | 3       |
| 4    | 3          | 3       |
| 4    | 3          | 3       |
| 5    | 1          | 1       |
+------+------------+---------+

Se vuoi conteggiare il numero di valori distinti di un'espressione per cui è soddisfatta una determinata condizione, puoi utilizzare questa ricetta:

COUNT(DISTINCT IF(condition, expression, NULL))

In questo caso, IF restituirà il valore di expression se condition è TRUE o NULL in caso contrario. L'elemento COUNT(DISTINCT ...) circostante ignorerà i valori NULL, pertanto conteggia solo i valori distinti di expression per i quali condition è TRUE.

Ad esempio, per contare il numero di valori positivi distinti di x:

SELECT COUNT(DISTINCT IF(x > 0, x, NULL)) AS distinct_positive
FROM UNNEST([1, -2, 4, 1, -5, 4, 1, 3, -6, 1]) AS x;

+-------------------+
| distinct_positive |
+-------------------+
| 3                 |
+-------------------+

o per contare il numero di date distinte in cui si è verificato un determinato tipo di evento:

WITH Events AS (
  SELECT DATE '2021-01-01' AS event_date, 'SUCCESS' AS event_type
  UNION ALL
  SELECT DATE '2021-01-02' AS event_date, 'SUCCESS' AS event_type
  UNION ALL
  SELECT DATE '2021-01-02' AS event_date, 'FAILURE' AS event_type
  UNION ALL
  SELECT DATE '2021-01-03' AS event_date, 'SUCCESS' AS event_type
  UNION ALL
  SELECT DATE '2021-01-04' AS event_date, 'FAILURE' AS event_type
  UNION ALL
  SELECT DATE '2021-01-04' AS event_date, 'FAILURE' AS event_type
)
SELECT
  COUNT(DISTINCT IF(event_type = 'FAILURE', event_date, NULL))
    AS distinct_dates_with_failures
FROM Events;

+------------------------------+
| distinct_dates_with_failures |
+------------------------------+
| 2                            |
+------------------------------+

CONTA.SE

COUNTIF(
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce il conteggio dei valori di TRUE per expression. Restituisce 0 se sono presenti righe di input pari a zero oppure se expression restituisce FALSE o NULL per tutte le righe.

Poiché expression deve essere un BOOL, il modulo COUNTIF(DISTINCT ...) non è supportato. Non sarebbe utile: esiste un solo valore distinto di TRUE. In genere, quando qualcuno vuole combinare COUNTIF e DISTINCT, vuole conteggiare il numero di valori distinti di un'espressione per la quale una determinata condizione è soddisfatta. Una ricetta per ottenere questo risultato è la seguente:

COUNT(DISTINCT IF(condition, expression, NULL))

Tieni presente che utilizza COUNT, non COUNTIF; la parte IF è stata spostata all'interno. Per scoprire di più, vedi gli esempi relativi a COUNT.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipi di argomenti supportati

BOOL

Tipi di dati restituiti

INT64

Esempi

SELECT COUNTIF(x<0) AS num_negative, COUNTIF(x>0) AS num_positive
FROM UNNEST([5, -2, 3, 6, -10, -7, 4, 0]) AS x;

+--------------+--------------+
| num_negative | num_positive |
+--------------+--------------+
| 3            | 4            |
+--------------+--------------+

SELECT
  x,
  COUNTIF(x<0) OVER (ORDER BY ABS(x) ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS num_negative
FROM UNNEST([5, -2, 3, 6, -10, NULL, -7, 4, 0]) AS x;

+------+--------------+
| x    | num_negative |
+------+--------------+
| NULL | 0            |
| 0    | 1            |
| -2   | 1            |
| 3    | 1            |
| 4    | 0            |
| 5    | 0            |
| 6    | 1            |
| -7   | 2            |
| -10  | 2            |
+------+--------------+

LOGICA_E

LOGICAL_AND(
  expression
)

Descrizione

Restituisce l'AND logico di tutte le espressioni non NULL. Restituisce NULL se non ci sono righe di input o expression restituisce NULL per tutte le righe.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Tipi di argomenti supportati

BOOL

Tipi di dati restituiti

BOOL

Esempi

SELECT LOGICAL_AND(x) AS logical_and FROM UNNEST([true, false, true]) AS x;

+-------------+
| logical_and |
+-------------+
| false       |
+-------------+

LOGICA_OPPURE

LOGICAL_OR(
  expression
)

Descrizione

Restituisce l'operatore logico OR di tutte le espressioni non NULL. Restituisce NULL se non ci sono righe di input o expression restituisce NULL per tutte le righe.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Tipi di argomenti supportati

BOOL

Tipi di dati restituiti

BOOL

Esempi

SELECT LOGICAL_OR(x) AS logical_or FROM UNNEST([true, false, true]) AS x;

+------------+
| logical_or |
+------------+
| true       |
+------------+

MAX

MAX(
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce il valore massimo delle espressioni non NULL. Restituisce NULL se non ci sono righe di input o expression restituisce NULL per tutte le righe. Restituisce NaN se l'input contiene un NaN.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Questa funzione supporta la specifica collatura.

Tipi di argomenti supportati

Qualsiasi tipo di dati ordinabile.

Tipi di dati restituiti

Uguale al tipo di dati utilizzato come valore di input.

Esempi

SELECT MAX(x) AS max
FROM UNNEST([8, 37, 4, 55]) AS x;

+-----+
| max |
+-----+
| 55  |
+-----+

SELECT x, MAX(x) OVER (PARTITION BY MOD(x, 2)) AS max
FROM UNNEST([8, NULL, 37, 4, NULL, 55]) AS x;

+------+------+
| x    | max  |
+------+------+
| NULL | NULL |
| NULL | NULL |
| 8    | 8    |
| 4    | 8    |
| 37   | 55   |
| 55   | 55   |
+------+------+

MIN

MIN(
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce il valore minimo delle espressioni non NULL. Restituisce NULL se non ci sono righe di input o expression restituisce NULL per tutte le righe. Restituisce NaN se l'input contiene un NaN.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Questa funzione supporta la specifica collatura.

Tipi di argomenti supportati

Qualsiasi tipo di dati ordinabile.

Tipi di dati restituiti

Uguale al tipo di dati utilizzato come valore di input.

Esempi

SELECT MIN(x) AS min
FROM UNNEST([8, 37, 4, 55]) AS x;

+-----+
| min |
+-----+
| 4   |
+-----+

SELECT x, MIN(x) OVER (PARTITION BY MOD(x, 2)) AS min
FROM UNNEST([8, NULL, 37, 4, NULL, 55]) AS x;

+------+------+
| x    | min  |
+------+------+
| NULL | NULL |
| NULL | NULL |
| 8    | 4    |
| 4    | 4    |
| 37   | 37   |
| 55   | 37   |
+------+------+

STRING_AGG

STRING_AGG(
  [ DISTINCT ]
  expression [, delimiter]
  [ ORDER BY key [ { ASC | DESC } ] [, ... ] ]
  [ LIMIT n ]
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce un valore (STRING o BYTES) ottenuto mediante la concatenazione di valori non NULL. Restituisce NULL se non ci sono righe di input o expression valuta NULL per tutte le righe.

Se delimiter è specificato, i valori concatenati sono separati da quel delimitatore; in caso contrario, viene utilizzato un punto come delimitatore.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipi di argomenti supportati

STRING o BYTES.

Tipi di dati restituiti

STRING o BYTES.

Esempi

SELECT STRING_AGG(fruit) AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;

+------------------------+
| string_agg             |
+------------------------+
| apple,pear,banana,pear |
+------------------------+

SELECT STRING_AGG(fruit, " & ") AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+------------------------------+
| string_agg                   |
+------------------------------+
| apple & pear & banana & pear |
+------------------------------+

SELECT STRING_AGG(DISTINCT fruit, " & ") AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+-----------------------+
| string_agg            |
+-----------------------+
| apple & pear & banana |
+-----------------------+

SELECT STRING_AGG(fruit, " & " ORDER BY LENGTH(fruit)) AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+------------------------------+
| string_agg                   |
+------------------------------+
| pear & pear & apple & banana |
+------------------------------+

SELECT STRING_AGG(fruit, " & " LIMIT 2) AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+--------------+
| string_agg   |
+--------------+
| apple & pear |
+--------------+

SELECT STRING_AGG(DISTINCT fruit, " & " ORDER BY fruit DESC LIMIT 2) AS string_agg
FROM UNNEST(["apple", "pear", "banana", "pear"]) AS fruit;

+---------------+
| string_agg    |
+---------------+
| pear & banana |
+---------------+

SELECT
  fruit,
  STRING_AGG(fruit, " & ") OVER (ORDER BY LENGTH(fruit)) AS string_agg
FROM UNNEST(["apple", NULL, "pear", "banana", "pear"]) AS fruit;

+--------+------------------------------+
| fruit  | string_agg                   |
+--------+------------------------------+
| NULL   | NULL                         |
| pear   | pear & pear                  |
| pear   | pear & pear                  |
| apple  | pear & pear & apple          |
| banana | pear & pear & apple & banana |
+--------+------------------------------+

SOMMA

SUM(
  [ DISTINCT ]
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce la somma di valori non vuoti.

Se l'espressione è un valore in virgola mobile, la somma non è deterministica, il che significa che potresti ricevere un risultato diverso ogni volta che utilizzi questa funzione.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipi di argomenti supportati

Eventuali tipi di dati numerici supportati e INTERVAL.

Tipi di dati restituiti

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64	INTERVALLO
USCITA	INT64	NUMERICO	BIGNUMERICA	FLOAT64	INTERVALLO

Casi speciali:

Restituisce NULL se l'input contiene solo NULL.

Restituisce NULL se l'input non contiene righe.

Restituisce Inf se l'input contiene Inf.

Restituisce -Inf se l'input contiene -Inf.

Restituisce NaN se l'input contiene un NaN.

Restituisce NaN se l'input contiene una combinazione di Inf e -Inf.

Esempi

SELECT SUM(x) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+-----+
| sum |
+-----+
| 25  |
+-----+

SELECT SUM(DISTINCT x) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+-----+
| sum |
+-----+
| 15  |
+-----+

SELECT
  x,
  SUM(x) OVER (PARTITION BY MOD(x, 3)) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+---+-----+
| x | sum |
+---+-----+
| 3 | 6   |
| 3 | 6   |
| 1 | 10  |
| 4 | 10  |
| 4 | 10  |
| 1 | 10  |
| 2 | 9   |
| 5 | 9   |
| 2 | 9   |
+---+-----+

SELECT
  x,
  SUM(DISTINCT x) OVER (PARTITION BY MOD(x, 3)) AS sum
FROM UNNEST([1, 2, 3, 4, 5, 4, 3, 2, 1]) AS x;

+---+-----+
| x | sum |
+---+-----+
| 3 | 3   |
| 3 | 3   |
| 1 | 5   |
| 4 | 5   |
| 4 | 5   |
| 1 | 5   |
| 2 | 7   |
| 5 | 7   |
| 2 | 7   |
+---+-----+

SELECT SUM(x) AS sum
FROM UNNEST([]) AS x;

+------+
| sum  |
+------+
| NULL |
+------+

Funzioni di aggregazione statistica

In SQL standard di Google sono disponibili le seguenti funzioni aggregate di statistiche. Per informazioni sulla sintassi per le chiamate di funzione aggregate, consulta Chiamate di funzione aggregate.

Corretta

CORR(
  X1, X2
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce il coefficiente di Pearson di correlazione di un insieme di coppie di numeri. Per ogni coppia di numeri, il primo numero è la variabile dipendente e il secondo numero la variabile indipendente. Il risultato del reso è compreso tra -1 e 1. Un risultato di 0 indica che non sono presenti problemi.

Sono supportati tutti i tipi numerici. Se l'input è NUMERIC o BIGNUMERIC, l'aggregazione interna è stabile con l'output finale convertito in FLOAT64. In caso contrario, l'input viene convertito in un valore FLOAT64 prima dell'aggregazione, generando un risultato potenzialmente instabile.

Questa funzione ignora qualsiasi coppia di input che contiene uno o più valori NULL. Se ci sono meno di due coppie di input senza valori NULL, questa funzione restituisce NULL.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di dati da restituire

FLOAT64

COVAR_POP

COVAR_POP(
  X1, X2
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce la covarianza della popolazione di un insieme di coppie di numeri. Il primo numero è la variabile dipendente, mentre il secondo è la variabile indipendente. Il risultato del reso è compreso tra -Inf e +Inf.

Questa funzione ignora qualsiasi coppia di input che contiene uno o più valori NULL. Se non è presente una coppia di input senza valori NULL, questa funzione restituisce NULL. Se esiste esattamente una coppia di input senza valori NULL, questa funzione restituisce 0.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di dati da restituire

FLOAT64

COVAR_SAMP

COVAR_SAMP(
  X1, X2
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce la covarianza di esempio di un insieme di coppie di numeri. Il primo numero è la variabile dipendente, mentre il secondo è la variabile indipendente. Il risultato del reso è compreso tra -Inf e +Inf.

Questa funzione ignora qualsiasi coppia di input che contiene uno o più valori NULL. Se ci sono meno di due coppie di input senza valori NULL, questa funzione restituisce NULL.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di dati da restituire

FLOAT64

STDDEV_POP

STDDEV_POP(
  [ DISTINCT ]
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce la deviazione standard dei valori (biasso) dei valori. Il risultato del reso è compreso tra 0 e +Inf.

Questa funzione ignora tutti gli input NULL. Se tutti gli input vengono ignorati, questa funzione restituisce NULL.

Se questa funzione riceve un singolo input non NULL, restituisce 0.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di dati da restituire

FLOAT64

STDDEV_SAMP

STDDEV_SAMP(
  [ DISTINCT ]
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce la deviazione standard (non obiettiva) del campione dei valori. Il risultato del reso è compreso tra 0 e +Inf.

Questa funzione ignora tutti gli input NULL. Se ci sono meno di due input non NULL, questa funzione restituisce NULL.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di dati da restituire

FLOAT64

Deviazione sviluppo

STDDEV(
  [ DISTINCT ]
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Un alias di STDDEV_SAMP.

VAR_POP

VAR_POP(
  [ DISTINCT ]
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce la varianza della popolazione (biasso) dei valori. Il risultato del reso è compreso tra 0 e +Inf.

Questa funzione ignora tutti gli input NULL. Se tutti gli input vengono ignorati, questa funzione restituisce NULL.

Se questa funzione riceve un singolo input non NULL, restituisce 0.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di dati da restituire

FLOAT64

VAR_SAMP

VAR_SAMP(
  [ DISTINCT ]
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Restituisce la varianza di esempio dei valori (non obiettiva). Il risultato del reso è compreso tra 0 e +Inf.

Questa funzione ignora tutti gli input NULL. Se ci sono meno di due input non NULL, questa funzione restituisce NULL.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di dati da restituire

FLOAT64

VARIABILI

VARIANCE(
  [ DISTINCT ]
  expression
)
[ OVER over_clause ]

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]
  [ window_frame_clause ]

Descrizione

Un alias di VAR_SAMP.

Funzioni di aggregazione approssimativa

In SQL standard di Google sono disponibili le seguenti funzioni aggregate approssimative. Per informazioni sulla sintassi per le chiamate di funzione aggregate, consulta Chiamate di funzione aggregate.

Le funzioni aggregate approssimative sono scalabili in termini di utilizzo e tempo della memoria, ma consentono di ottenere risultati approssimativi anziché risultati esatti. Queste funzioni in genere richiedono meno memoria rispetto alle funzioni di aggregazione esatta, come COUNT(DISTINCT ...), ma presentano anche incertezza statistica. Ciò rende l'aggregazione approssimativa appropriata per stream di dati di grandi dimensioni per i quali l'utilizzo della memoria lineare è poco pratico, nonché per i dati già approssimativi.

Le funzioni aggregate approssimative di questa sezione funzionano direttamente con i dati di input, anziché con una stima intermedia dei dati. Queste funzioni non consentono agli utenti di specificare la precisione per la stima con i disegni. Se vuoi specificare la precisione con gli schizzi, consulta:

Funzioni di HyperLogLog++ per stimare la cardinalità.

APPROX_COUNT_DISTINCT

APPROX_COUNT_DISTINCT(
  expression
)

Descrizione

Restituisce il risultato approssimativo di COUNT(DISTINCT expression). Il valore restituito è una stima statistica, non necessariamente il valore effettivo.

Questa funzione è meno precisa di COUNT(DISTINCT expression), ma ha prestazioni migliori con un input enorme.

Tipi di argomenti supportati

Qualsiasi tipo di dati tranne: ARRAY STRUCT

Tipi di dati restituiti

INT64

Esempi

SELECT APPROX_COUNT_DISTINCT(x) as approx_distinct
FROM UNNEST([0, 1, 1, 2, 3, 5]) as x;

+-----------------+
| approx_distinct |
+-----------------+
| 5               |
+-----------------+

APPROX_QUANTILES

APPROX_QUANTILES(
  [ DISTINCT ]
  expression, number
  [ { IGNORE | RESPECT } NULLS ]
)

Descrizione

Restituisce i limiti approssimativi per un gruppo di valori expression, dove number rappresenta il numero di quantili da creare. Questa funzione restituisce un array di elementi number + 1, dove il primo elemento è il valore minimo approssimativo e l'ultimo elemento è il valore massimo approssimativo.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Tipi di argomenti supportati

expression può essere qualsiasi tipo di dati supportato tranne: ARRAY STRUCT

number deve essere INT64.

Tipi di dati restituiti

Un ARRAY del tipo specificato dal parametro expression.

Restituisce NULL se non sono presenti righe di input o expression restituisce NULL per tutte le righe.

Esempi

SELECT APPROX_QUANTILES(x, 2) AS approx_quantiles
FROM UNNEST([1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [1, 5, 10]       |
+------------------+

SELECT APPROX_QUANTILES(x, 100)[OFFSET(90)] AS percentile_90
FROM UNNEST([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) AS x;

+---------------+
| percentile_90 |
+---------------+
| 9             |
+---------------+

SELECT APPROX_QUANTILES(DISTINCT x, 2) AS approx_quantiles
FROM UNNEST([1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [1, 6, 10]       |
+------------------+

SELECT FORMAT("%T", APPROX_QUANTILES(x, 2 RESPECT NULLS)) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [NULL, 4, 10]    |
+------------------+

SELECT FORMAT("%T", APPROX_QUANTILES(DISTINCT x, 2 RESPECT NULLS)) AS approx_quantiles
FROM UNNEST([NULL, NULL, 1, 1, 1, 4, 5, 6, 7, 8, 9, 10]) AS x;

+------------------+
| approx_quantiles |
+------------------+
| [NULL, 6, 10]    |
+------------------+

APPROX_TOP_COUNT

APPROX_TOP_COUNT(
  expression, number
)

Descrizione

Restituisce gli elementi superiori approssimativi di expression. Il parametro number specifica il numero di elementi restituiti.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Tipi di argomenti supportati

expression può essere di qualsiasi tipo di dati supportato dalla clausola GROUP BY.

number deve essere INT64.

Tipi di dati restituiti

Un ARRAY di tipo STRUCT. Lo STRUCT contiene due campi. Il primo campo (denominato value) contiene un valore di input. Il secondo campo (denominato count) contiene un INT64 che specifica il numero di volte in cui è stato restituito il valore.

Restituisce NULL se non ci sono righe di input.

Esempi

SELECT APPROX_TOP_COUNT(x, 2) as approx_top_count
FROM UNNEST(["apple", "apple", "pear", "pear", "pear", "banana"]) as x;

+-------------------------+
| approx_top_count        |
+-------------------------+
| [{pear, 3}, {apple, 2}] |
+-------------------------+

Gestione NULL

APPROX_TOP_COUNT non ignora NULL nell'input. Ad esempio:

SELECT APPROX_TOP_COUNT(x, 2) as approx_top_count
FROM UNNEST([NULL, "pear", "pear", "pear", "apple", NULL]) as x;

+------------------------+
| approx_top_count       |
+------------------------+
| [{pear, 3}, {NULL, 2}] |
+------------------------+

APPROX_TOP_SUM

APPROX_TOP_SUM(
  expression, weight, number
)

Descrizione

Restituisce gli elementi superiori approssimativi di expression, in base alla somma di un elemento weight assegnato. Il parametro number specifica il numero di elementi restituiti.

Se l'input di weight è negativo o NaN, questa funzione restituisce un errore.

Per saperne di più sugli argomenti facoltativi in questa funzione e su come utilizzarli, consulta la sezione Chiamate delle funzioni aggregate.

Tipi di argomenti supportati

expression può essere di qualsiasi tipo di dati supportato dalla clausola GROUP BY.

weight deve essere uno dei seguenti:

INT64
NUMERIC
BIGNUMERIC
FLOAT64

number deve essere INT64.

Tipi di dati restituiti

Un ARRAY di tipo STRUCT. Lo STRUCT contiene due campi: value e sum. Il campo value contiene il valore dell'espressione di input. Il campo sum è dello stesso tipo di weight ed è la somma approssimativa della ponderazione di input associata al campo value.

Restituisce NULL se non ci sono righe di input.

Esempi

SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([
  STRUCT("apple" AS x, 3 AS weight),
  ("pear", 2),
  ("apple", 0),
  ("banana", 5),
  ("pear", 4)
]);

+--------------------------+
| approx_top_sum           |
+--------------------------+
| [{pear, 6}, {banana, 5}] |
+--------------------------+

Gestione NULL

APPROX_TOP_SUM non ignora i valori NULL per i parametri expression e weight.

SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, NULL AS weight), ("pear", 0), ("pear", NULL)]);

+----------------------------+
| approx_top_sum             |
+----------------------------+
| [{pear, 0}, {apple, NULL}] |
+----------------------------+

SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, 0 AS weight), (NULL, 2)]);

+-------------------------+
| approx_top_sum          |
+-------------------------+
| [{NULL, 2}, {apple, 0}] |
+-------------------------+

SELECT APPROX_TOP_SUM(x, weight, 2) AS approx_top_sum FROM
UNNEST([STRUCT("apple" AS x, 0 AS weight), (NULL, NULL)]);

+----------------------------+
| approx_top_sum             |
+----------------------------+
| [{apple, 0}, {NULL, NULL}] |
+----------------------------+

Funzioni HyperLogLog++

L'algoritmo HyperLogLog++ (HLL++) stima la cardinalità dagli schemi. Se non vuoi lavorare con gli schizzi e non hai bisogno di una precisione personalizzata, potresti usare funzioni aggregate approssimative con la precisione definita dal sistema.

Le funzioni HLL++ sono funzioni aggregate approssimative. L'aggregazione approssimativa richiede in genere meno memoria rispetto alle funzioni di aggregazione esatta, come COUNT(DISTINCT), ma introduce anche incertezza statistica. In questo modo le funzioni HLL++ sono appropriate per grandi flussi di dati, per cui l'utilizzo della memoria lineare non è fattibile, nonché per i dati già approssimativi.

BigQuery supporta le seguenti funzioni HLL++:

HLL_COUNT.INIT

HLL_COUNT.INIT(input [, precision])

Descrizione

Una funzione aggregata che prende uno o più valori input e li aggrega in uno schizzo HLL++. Ogni schizzo viene rappresentato utilizzando il tipo di dati BYTES. Puoi quindi unire gli schizzi utilizzando HLL_COUNT.MERGE o HLL_COUNT.MERGE_PARTIAL. Se non è necessaria alcuna unione, puoi estrarre il conteggio finale di valori distinti dallo schizzo utilizzando HLL_COUNT.EXTRACT.

Questa funzione supporta un parametro facoltativo, precision. Questo parametro definisce la precisione della stima al costo di memoria aggiuntiva necessaria per elaborare gli schizzi o archiviarli su disco. La tabella seguente mostra i valori di precisione consentiti, la dimensione massima degli schizzi per gruppo e l'intervallo di confidenza (CI) delle precisione tipiche:

Precisione	Dimensione massima schizzo (KiB)	65% CI	IC 95%	IC 99%
10	1	±3,25%	±6,50%	±9,75%
11	2	±2,30%	±4,60%	±6,89%
12	4	±1,63%	±3,25%	±4,88%
13	8	±1,15%	±2,30%	±3,45%
14	16	±0,81%	±1,63%	±2,44%
15 (valore predefinito)	32	±0,57%	±1,15%	±1,72%
16	64	±0,41%	±0,81%	±1,22%
17	128	±0,29%	±0,57%	±0,86%
18	256	±0,20%	±0,41%	±0,61%
19	512	±0,14%	±0,29%	±0,43%
20	1024	±0,10%	±0,20%	±0,30%
21	2048	±0,07%	±0,14%	±0,22%
22	4096	±0,05%	±0,10%	±0,15%
23	8192	±0,04%	±0,07%	±0,11%
24	16384	±0,03%	±0,05%	±0,08%

Se il valore inserito è NULL, questa funzione restituisce NULL.

Per ulteriori informazioni, consulta HyperLogLog in Practice: Algorithmic Engineering of a State of The Art Cardinality Estimation Algorithm.

Tipi di input supportati

INT64
NUMERIC
BIGNUMERIC
STRING
BYTES

Tipo di reso

BYTES

Esempio

SELECT
  HLL_COUNT.INIT(respondent) AS respondents_hll,
  flavor,
  country
FROM UNNEST([
  STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
  (1, "Chocolate", "CH"),
  (2, "Chocolate", "US"),
  (2, "Strawberry", "US")])
GROUP BY flavor, country;

HLL_COUNT

HLL_COUNT.MERGE(sketch)

Descrizione

Una funzione aggregata che restituisce la cardinalità di diversi set di schizzi HLL++ elaborando la propria unione.

Ogni elemento sketch deve essere inizializzato sullo stesso tipo. I tentativi di unire gli schizzi per diversi tipi generano un errore. Ad esempio, non puoi unire uno schizzo inizializzato dai dati INT64 con uno inizializzato dai dati STRING.

Se gli schizzi uniti sono stati inizializzati con precise, verrà eseguito il downgrade della precisione alla precisione più bassa coinvolta nell'unione.

Questa funzione ignora i valori NULL durante l'unione degli schizzi. Se l'unione avviene su zero righe o solo su valori NULL, la funzione restituisce 0.

Tipi di input supportati

BYTES

Tipo di reso

INT64

Esempio

SELECT HLL_COUNT.MERGE(respondents_hll) AS num_respondents, flavor
FROM (
  SELECT
    HLL_COUNT.INIT(respondent) AS respondents_hll,
    flavor,
    country
  FROM UNNEST([
    STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
    (1, "Chocolate", "CH"),
    (2, "Chocolate", "US"),
    (2, "Strawberry", "US")])
  GROUP BY flavor, country)
GROUP BY flavor;

HLL_COUNT.MERGE_PARTIAL

HLL_COUNT.MERGE_PARTIAL(sketch)

Descrizione

Una funzione aggregata che prende uno o più input sketchHLL++ e li unisce in un nuovo schizzo.

Se gli schizzi uniti sono stati inizializzati con precise, verrà eseguito il downgrade della precisione alla precisione più bassa coinvolta nell'unione. Ad esempio, se MERGE_PARTIAL rileva schizzi di precisione 14 e 15, il nuovo schizzo restituito avrà precisione 14.

Questa funzione restituisce NULL se non è presente alcun input oppure se tutti gli input sono NULL.

Tipi di input supportati

BYTES

Tipo di reso

BYTES

Esempio

SELECT HLL_COUNT.MERGE_PARTIAL(respondents_hll) AS num_respondents, flavor
FROM (
  SELECT
    HLL_COUNT.INIT(respondent) AS respondents_hll,
    flavor,
    country
  FROM UNNEST([
    STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
    (1, "Chocolate", "CH"),
    (2, "Chocolate", "US"),
    (2, "Strawberry", "US")])
  GROUP BY flavor, country)
GROUP BY flavor;

HLL_COUNT.EXTRACT

HLL_COUNT.EXTRACT(sketch)

Descrizione

Una funzione scalare che estrae una stima di cardinalità di un singolo schizzo HLL++.

Se sketch è NULL, questa funzione restituisce una stima di cardinalità di 0.

Tipi di input supportati

BYTES

Tipo di reso

INT64

Esempio

SELECT
  flavor,
  country,
  HLL_COUNT.EXTRACT(respondents_hll) AS num_respondents
FROM (
  SELECT
    HLL_COUNT.INIT(respondent) AS respondents_hll,
    flavor,
    country
  FROM UNNEST([
    STRUCT(1 AS respondent, "Vanilla" AS flavor, "CH" AS country),
    (1, "Chocolate", "CH"),
    (2, "Chocolate", "US"),
    (2, "Strawberry", "US")])
  GROUP BY flavor, country);

+------------+---------+-----------------+
| flavor     | country | num_respondents |
+------------+---------+-----------------+
| Vanilla    | CH      | 1               |
| Chocolate  | CH      | 1               |
| Chocolate  | US      | 1               |
| Strawberry | US      | 1               |
+------------+---------+-----------------+

Informazioni sull'algoritmo HLL++

L'algoritmo HLL++ migliora l'algoritmo HLL stimando con precisione le cardinalità molto piccole e grandi. L'algoritmo HLL++ include una funzione hash a 64 bit, una rappresentazione sparsa per ridurre i requisiti di memoria per le stime di cardinalità piccole e la correzione dei bias empirica per le stime di cardinalità piccole.

Informazioni sugli schizzi

Uno schizzo è un riepilogo di uno stream di dati di grandi dimensioni. Puoi estrarre statistiche da uno schizzo per stimare statistiche specifiche dei dati originali o unire gli schizzi per riepilogare più stream di dati. Uno schizzo ha queste funzionalità:

Comprime i dati non elaborati in una rappresentazione a memoria fissa.
È asintomatico più piccolo dell'input.
È la forma serializzata di una struttura di dati sublineati in memoria.
In genere richiede meno memoria rispetto all'input utilizzato per crearla.

Gli schizzi consentono l'integrazione con altri sistemi. Ad esempio, è possibile creare schizzi in applicazioni esterne, come Cloud Dataflow o Apache Spark, e utilizzarle in BigQuery o viceversa. Gli schizzi consentono anche di creare aggregazioni intermedie per funzioni non aggiuntive come COUNT(DISTINCT).

Funzioni di numerazione

Le seguenti sezioni descrivono le funzioni di numerazione supportate da BigQuery. Le funzioni di numerazione sono un sottoinsieme delle funzioni della finestra. Per creare una chiamata a funzione finestra e saperne di più sulla sintassi per le funzioni finestra, consulta Chiamate funzione finestra.

Le funzioni di numerazione assegnano valori interi a ogni riga in base alla loro posizione nella finestra specificata. La sintassi della clausola OVER varia in base alle funzioni di numerazione.

POSIZIONE

RANK()
OVER over_clause

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  ORDER BY expression [ { ASC | DESC }  ] [, ...]

Descrizione

Restituisce il ranking ordinale (basato su 1) di ogni riga all'interno della partizione ordinata. Tutte le righe delle app peer ricevono lo stesso valore di ranking. La riga successiva o l'insieme di righe peer riceve un valore di ranking che aumenta in base al numero di peer con valore di ranking precedente, anziché DENSE_RANK, che aumenta sempre di 1.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di reso

INT64

Esempi

WITH Numbers AS
 (SELECT 1 as x
  UNION ALL SELECT 2
  UNION ALL SELECT 2
  UNION ALL SELECT 5
  UNION ALL SELECT 8
  UNION ALL SELECT 10
  UNION ALL SELECT 10
)
SELECT x,
  RANK() OVER (ORDER BY x ASC) AS rank
FROM Numbers

+-------------------------+
| x          | rank       |
+-------------------------+
| 1          | 1          |
| 2          | 2          |
| 2          | 2          |
| 5          | 4          |
| 8          | 5          |
| 10         | 6          |
| 10         | 6          |
+-------------------------+

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 2:59:01', 'F30-34')
SELECT name,
  finish_time,
  division,
  RANK() OVER (PARTITION BY division ORDER BY finish_time ASC) AS finish_rank
FROM finishers;

+-----------------+------------------------+----------+-------------+
| name            | finish_time            | division | finish_rank |
+-----------------+------------------------+----------+-------------+
| Sophia Liu      | 2016-10-18 09:51:45+00 | F30-34   | 1           |
| Meghan Lederer  | 2016-10-18 09:59:01+00 | F30-34   | 2           |
| Nikki Leith     | 2016-10-18 09:59:01+00 | F30-34   | 2           |
| Jen Edwards     | 2016-10-18 10:06:36+00 | F30-34   | 4           |
| Lisa Stelzner   | 2016-10-18 09:54:11+00 | F35-39   | 1           |
| Lauren Matthews | 2016-10-18 10:01:17+00 | F35-39   | 2           |
| Desiree Berry   | 2016-10-18 10:05:42+00 | F35-39   | 3           |
| Suzy Slane      | 2016-10-18 10:06:24+00 | F35-39   | 4           |
+-----------------+------------------------+----------+-------------+

DENSE_RANK

DENSE_RANK()
OVER over_clause

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  ORDER BY expression [ { ASC | DESC }  ] [, ...]

Descrizione

Restituisce il ranking ordinale (1-basato) di ogni riga all'interno della partizione della finestra. Tutte le righe delle app peer ricevono lo stesso valore di ranking, mentre il valore di ranking successivo viene incrementato di uno.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di reso

INT64

Esempi

WITH Numbers AS
 (SELECT 1 as x
  UNION ALL SELECT 2
  UNION ALL SELECT 2
  UNION ALL SELECT 5
  UNION ALL SELECT 8
  UNION ALL SELECT 10
  UNION ALL SELECT 10
)
SELECT x,
  DENSE_RANK() OVER (ORDER BY x ASC) AS dense_rank
FROM Numbers

+-------------------------+
| x          | dense_rank |
+-------------------------+
| 1          | 1          |
| 2          | 2          |
| 2          | 2          |
| 5          | 3          |
| 8          | 4          |
| 10         | 5          |
| 10         | 5          |
+-------------------------+

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 2:59:01', 'F30-34')
SELECT name,
  finish_time,
  division,
  DENSE_RANK() OVER (PARTITION BY division ORDER BY finish_time ASC) AS finish_rank
FROM finishers;

+-----------------+------------------------+----------+-------------+
| name            | finish_time            | division | finish_rank |
+-----------------+------------------------+----------+-------------+
| Sophia Liu      | 2016-10-18 09:51:45+00 | F30-34   | 1           |
| Meghan Lederer  | 2016-10-18 09:59:01+00 | F30-34   | 2           |
| Nikki Leith     | 2016-10-18 09:59:01+00 | F30-34   | 2           |
| Jen Edwards     | 2016-10-18 10:06:36+00 | F30-34   | 3           |
| Lisa Stelzner   | 2016-10-18 09:54:11+00 | F35-39   | 1           |
| Lauren Matthews | 2016-10-18 10:01:17+00 | F35-39   | 2           |
| Desiree Berry   | 2016-10-18 10:05:42+00 | F35-39   | 3           |
| Suzy Slane      | 2016-10-18 10:06:24+00 | F35-39   | 4           |
+-----------------+------------------------+----------+-------------+

PERCENT_RANK

PERCENT_RANK()
OVER over_clause

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  ORDER BY expression [ { ASC | DESC }  ] [, ...]

Descrizione

Restituisce il ranking percentile di una riga definita come (RK-1)/(NR-1), dove RK è il RANK della riga e NR è il numero di righe nella partizione. Restituisce 0 se NR=1.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di reso

FLOAT64

Esempio

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 2:59:01', 'F30-34')
SELECT name,
  finish_time,
  division,
  PERCENT_RANK() OVER (PARTITION BY division ORDER BY finish_time ASC) AS finish_rank
FROM finishers;

+-----------------+------------------------+----------+---------------------+
| name            | finish_time            | division | finish_rank         |
+-----------------+------------------------+----------+---------------------+
| Sophia Liu      | 2016-10-18 09:51:45+00 | F30-34   | 0                   |
| Meghan Lederer  | 2016-10-18 09:59:01+00 | F30-34   | 0.33333333333333331 |
| Nikki Leith     | 2016-10-18 09:59:01+00 | F30-34   | 0.33333333333333331 |
| Jen Edwards     | 2016-10-18 10:06:36+00 | F30-34   | 1                   |
| Lisa Stelzner   | 2016-10-18 09:54:11+00 | F35-39   | 0                   |
| Lauren Matthews | 2016-10-18 10:01:17+00 | F35-39   | 0.33333333333333331 |
| Desiree Berry   | 2016-10-18 10:05:42+00 | F35-39   | 0.66666666666666663 |
| Suzy Slane      | 2016-10-18 10:06:24+00 | F35-39   | 1                   |
+-----------------+------------------------+----------+---------------------+

CUME_DIST

CUME_DIST()
OVER over_clause

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  ORDER BY expression [ { ASC | DESC }  ] [, ...]

Descrizione

Restituisce il ranking relativo di una riga definita come NP/NR. NP è definito come il numero di righe che precedono o sono peer con la riga corrente. NR è il numero di righe nella partizione.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di reso

FLOAT64

Esempio

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 2:59:01', 'F30-34')
SELECT name,
  finish_time,
  division,
  CUME_DIST() OVER (PARTITION BY division ORDER BY finish_time ASC) AS finish_rank
FROM finishers;

+-----------------+------------------------+----------+-------------+
| name            | finish_time            | division | finish_rank |
+-----------------+------------------------+----------+-------------+
| Sophia Liu      | 2016-10-18 09:51:45+00 | F30-34   | 0.25        |
| Meghan Lederer  | 2016-10-18 09:59:01+00 | F30-34   | 0.75        |
| Nikki Leith     | 2016-10-18 09:59:01+00 | F30-34   | 0.75        |
| Jen Edwards     | 2016-10-18 10:06:36+00 | F30-34   | 1           |
| Lisa Stelzner   | 2016-10-18 09:54:11+00 | F35-39   | 0.25        |
| Lauren Matthews | 2016-10-18 10:01:17+00 | F35-39   | 0.5         |
| Desiree Berry   | 2016-10-18 10:05:42+00 | F35-39   | 0.75        |
| Suzy Slane      | 2016-10-18 10:06:24+00 | F35-39   | 1           |
+-----------------+------------------------+----------+-------------+

TUTTO

NTILE(constant_integer_expression)
OVER over_clause

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  ORDER BY expression [ { ASC | DESC }  ] [, ...]

Descrizione

Questa funzione suddivide le righe in bucket constant_integer_expression in base all'ordine delle righe e restituisce il numero di bucket basato su 1 assegnato a ciascuna riga. Il numero di righe nei bucket può variare al massimo di 1. I valori rimanenti (il resto del numero di righe diviso per i bucket) vengono distribuiti uno per ogni bucket, a partire dal bucket 1. Se constant_integer_expression restituisce NULL, 0 o un valore negativo, viene fornito un errore.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di reso

INT64

Esempio

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 2:59:01', 'F30-34')
SELECT name,
  finish_time,
  division,
  NTILE(3) OVER (PARTITION BY division ORDER BY finish_time ASC) AS finish_rank
FROM finishers;

+-----------------+------------------------+----------+-------------+
| name            | finish_time            | division | finish_rank |
+-----------------+------------------------+----------+-------------+
| Sophia Liu      | 2016-10-18 09:51:45+00 | F30-34   | 1           |
| Meghan Lederer  | 2016-10-18 09:59:01+00 | F30-34   | 1           |
| Nikki Leith     | 2016-10-18 09:59:01+00 | F30-34   | 2           |
| Jen Edwards     | 2016-10-18 10:06:36+00 | F30-34   | 3           |
| Lisa Stelzner   | 2016-10-18 09:54:11+00 | F35-39   | 1           |
| Lauren Matthews | 2016-10-18 10:01:17+00 | F35-39   | 1           |
| Desiree Berry   | 2016-10-18 10:05:42+00 | F35-39   | 2           |
| Suzy Slane      | 2016-10-18 10:06:24+00 | F35-39   | 3           |
+-----------------+------------------------+----------+-------------+

ROW_NUMBER

ROW_NUMBER()
OVER over_clause

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  [ ORDER BY expression [ { ASC | DESC }  ] [, ...] ]

Descrizione

Non richiede la clausola ORDER BY. Restituisce la ordinale della riga sequenziale (basata su 1) di ogni riga per ogni partizione ordinata. Se la clausola ORDER BY non è specificata, il risultato non è deterministico.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipo di reso

INT64

Esempi

WITH Numbers AS
 (SELECT 1 as x
  UNION ALL SELECT 2
  UNION ALL SELECT 2
  UNION ALL SELECT 5
  UNION ALL SELECT 8
  UNION ALL SELECT 10
  UNION ALL SELECT 10
)
SELECT x,
  ROW_NUMBER() OVER (ORDER BY x) AS row_num
FROM Numbers

+-------------------------+
| x          | row_num    |
+-------------------------+
| 1          | 1          |
| 2          | 2          |
| 2          | 3          |
| 5          | 4          |
| 8          | 5          |
| 10         | 6          |
| 10         | 7          |
+-------------------------+

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 2:59:01', 'F30-34')
SELECT name,
  finish_time,
  division,
  ROW_NUMBER() OVER (PARTITION BY division ORDER BY finish_time ASC) AS finish_rank
FROM finishers;

+-----------------+------------------------+----------+-------------+
| name            | finish_time            | division | finish_rank |
+-----------------+------------------------+----------+-------------+
| Sophia Liu      | 2016-10-18 09:51:45+00 | F30-34   | 1           |
| Meghan Lederer  | 2016-10-18 09:59:01+00 | F30-34   | 2           |
| Nikki Leith     | 2016-10-18 09:59:01+00 | F30-34   | 3           |
| Jen Edwards     | 2016-10-18 10:06:36+00 | F30-34   | 4           |
| Lisa Stelzner   | 2016-10-18 09:54:11+00 | F35-39   | 1           |
| Lauren Matthews | 2016-10-18 10:01:17+00 | F35-39   | 2           |
| Desiree Berry   | 2016-10-18 10:05:42+00 | F35-39   | 3           |
| Suzy Slane      | 2016-10-18 10:06:24+00 | F35-39   | 4           |
+-----------------+------------------------+----------+-------------+

Funzioni di bit

BigQuery supporta le seguenti funzioni bit.

BIT_COUNT

BIT_COUNT(expression)

Descrizione

L'input, expression, deve essere un numero intero o BYTES.

Restituisce il numero di bit impostati nell'input expression. Per i numeri interi firmati, questo è il numero di bit nella forma di completamento di due.

Tipo di dati da restituire

INT64

Esempio

SELECT a, BIT_COUNT(a) AS a_bits, FORMAT("%T", b) as b, BIT_COUNT(b) AS b_bits
FROM UNNEST([
  STRUCT(0 AS a, b'' AS b), (0, b'\x00'), (5, b'\x05'), (8, b'\x00\x08'),
  (0xFFFF, b'\xFF\xFF'), (-2, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFE'),
  (-1, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF'),
  (NULL, b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF')
]) AS x;

+-------+--------+---------------------------------------------+--------+
| a     | a_bits | b                                           | b_bits |
+-------+--------+---------------------------------------------+--------+
| 0     | 0      | b""                                         | 0      |
| 0     | 0      | b"\x00"                                     | 0      |
| 5     | 2      | b"\x05"                                     | 2      |
| 8     | 1      | b"\x00\x08"                                 | 1      |
| 65535 | 16     | b"\xff\xff"                                 | 16     |
| -2    | 63     | b"\xff\xff\xff\xff\xff\xff\xff\xfe"         | 63     |
| -1    | 64     | b"\xff\xff\xff\xff\xff\xff\xff\xff"         | 64     |
| NULL  | NULL   | b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" | 80     |
+-------+--------+---------------------------------------------+--------+

Funzioni di conversione

BigQuery supporta le seguenti funzioni di conversione. Le conversioni dei tipi di dati sono esplicite, ma alcune possono avvenire implicitamente. Per saperne di più sulle conversioni implicite ed esplicite, fai clic qui.

Panoramica di CAST

CAST(expression AS typename [format_clause])

Descrizione

La sintassi di trasmissione viene utilizzata in una query per indicare che il tipo di risultato di un'espressione deve essere convertito in un altro tipo.

Quando utilizzi CAST, una query può non riuscire se BigQuery non è in grado di eseguire la trasmissione. Se vuoi proteggere le tue query da questi tipi di errori, puoi utilizzare SAFE_CAST.

Le trasmissioni tra tipi supportati che non vengono mappate correttamente dal valore originale al dominio di destinazione generano errori di runtime. Ad esempio, la trasmissione di BYTES a STRING dove la sequenza di byte non è valida genera un errore di runtime.

Alcuni cast possono includere una clausola di formato, che fornisce istruzioni su come condurre la trasmissione. Ad esempio, potresti indicare a un Cast di convertire una sequenza di byte in una stringa con codifica BASE64 anziché con una codifica con codifica UTF-8.

La struttura della clausola relativa al formato è univoca per ogni tipo di elemento Cast e sono disponibili ulteriori informazioni nella sezione relativa a tale cast.

Esempi

La seguente query genera "true" se x è 1, "false" per qualsiasi altro valore non NULL e NULL se x è NULL.

CAST(x=1 AS STRING)

TRASCINA COME ARRAY

CAST(expression AS ARRAY<element_type>)

Descrizione

BigQuery supporta la trasmissione in ARRAY. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

ARRAY

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
ARRAY	ARRAY	Deve essere dello stesso tipo di ARRAY.

TRASMETTI COME BIGNUMERICO

CAST(expression AS BIGNUMERIC)

Descrizione

BigQuery supporta la trasmissione in BIGNUMERIC. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

INT64
FLOAT64
NUMERIC
BIGNUMERIC
STRING

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
FLOAT64	BIGNUMERICO	Il numero in virgola mobile si arrotonda per metà allo zero. La trasmissione di `NaN`, `+inf` o `-inf` restituirà un errore. La trasmissione di un valore al di fuori dell'intervallo di `BIGNUMERIC` restituirà un errore di overflow.
STRINGA	BIGNUMERICO	Il valore letterale numerico contenuto in `STRING` non deve superare la precisione o l'intervallo massimo del tipo `BIGNUMERIC`, altrimenti si verifica un errore. Se il numero di cifre dopo la virgola decimale supera 38, il valore risultante `BIGNUMERIC` verrà arrotondato a metà da zero per avere 38 cifre dopo la virgola.

CREA COME BOOL

CAST(expression AS BOOL)

Descrizione

BigQuery supporta la trasmissione in BOOL. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

INT64
BOOL
STRING

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
INT64	BOOL	Restituisce `FALSE` se `x` è `0`, `TRUE` in caso contrario.
STRINGA	BOOL	Restituisce `TRUE` se `x` è `"true"` e `FALSE` se `x` è `"false"` Tutti gli altri valori di `x` non sono validi e mostrano un errore di trasmissione a BOOL. Le stringhe non fanno distinzione tra maiuscole e minuscole durante la conversione in BOOL.

INIZIA COME BYTES

CAST(expression AS BYTES [format_clause])

Descrizione

BigQuery supporta la trasmissione a BYTES. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

BYTES
STRING

Clausola Format

Quando un'espressione di un tipo viene trasmessa a un altro tipo, puoi utilizzare la clausola di formato per fornire istruzioni su come eseguire la trasmissione. Puoi utilizzare la clausola di formato in questa sezione se il valore di expression è STRING.

Formattare la stringa come byte

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
STRINGA	BIT	Le STRINGE vengono trasmesse ai BYTES utilizzando la codifica UTF-8. Ad esempio, la stringa "©", quando trasmessa a BYTES, diventerà una sequenza di 2 byte con i valori esadecimali C2 e A9.

CREA COME DATA

CAST(expression AS DATE [format_clause])

Descrizione

BigQuery supporta la trasmissione in DATE. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

STRING
TIME
DATETIME
TIMESTAMP

Clausola Format

Formattare la stringa come data e ora

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
STRINGA	DATA	Durante la trasmissione da stringa a data, la stringa deve essere conforme al formato letterale di data supportato ed è indipendente dal fuso orario. Se l'espressione stringa non è valida o rappresenta una data al di fuori dell'intervallo minimo/massimo supportato, viene generato un errore.
TIMESTAMP	DATA	La trasmissione da un timestamp a oggi tronca efficacemente il timestamp in base al fuso orario predefinito.

CREA COME DATETIME

CAST(expression AS DATETIME [format_clause])

Descrizione

BigQuery supporta la trasmissione in DATETIME. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

STRING
TIME
DATETIME
TIMESTAMP

Clausola Format

Formattare la stringa come data e ora

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
STRINGA	DATA/Ora	Durante la trasmissione da stringa a data/ora, la stringa deve essere conforme al formato letterale di data e ora supportato ed è indipendente dal fuso orario. Se l'espressione della stringa non è valida o rappresenta un orario non compreso nell'intervallo minimo/massimo supportato, viene generato un errore.
TIMESTAMP	DATA/Ora	La trasmissione da timestamp a data e ora consente di troncare il timestamp in base al fuso orario predefinito.

CAST AS FLOAT64

CAST(expression AS FLOAT64)

Descrizione

BigQuery supporta la trasmissione in tipi di virgola mobile. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

INT64
FLOAT64
NUMERIC
BIGNUMERIC
STRING

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
INT64	FLOAT64	Restituisce un valore di virgola mobile simile, ma potenzialmente non preciso.
NUMERICO	FLOAT64	NUMERIC verrà convertito nel numero in virgola mobile più vicino con una possibile perdita di precisione.
BIGNUMERICA	FLOAT64	BIGNUMERIC verrà convertito nel numero in virgola mobile più vicino con una possibile perdita di precisione.
STRINGA	FLOAT64	Restituisce `x` come valore in virgola mobile, interpretandolo come con la stessa forma di un valore letterale in virgola mobile valido. Supporta anche i cast da `"[+,-]inf"` a `[,-]Infinity`, da `"[+,-]infinity"` a `[,-]Infinity` e da `"[+,-]nan"` a `NaN`. Le conversioni non fanno distinzione tra maiuscole e minuscole.

CAST AS INT64

CAST(expression AS INT64)

Descrizione

BigQuery supporta la trasmissione a tipi interi. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

INT64
FLOAT64
NUMERIC
BIGNUMERIC
BOOL
STRING

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
FLOAT64	INT64	Restituisce il valore intero più vicino. I casi a metà, come 1,5 o -0,5, vengono azzerati.
BOOL	INT64	Restituisce `1` se `x` è `TRUE`, `0` in caso contrario.
STRINGA	INT64	È possibile trasmettere una stringa esadecimale a un numero intero. Ad esempio, da `0x123` a `291` o da `-0x123` a `-291`.

Esempi

Se lavori con stringhe esadecimali (0x123), puoi trasmetterle come numeri interi:

SELECT '0x123' as hex_value, CAST('0x123' as INT64) as hex_to_int;

+-----------+------------+
| hex_value | hex_to_int |
+-----------+------------+
| 0x123     | 291        |
+-----------+------------+

SELECT '-0x123' as hex_value, CAST('-0x123' as INT64) as hex_to_int;

+-----------+------------+
| hex_value | hex_to_int |
+-----------+------------+
| -0x123    | -291       |
+-----------+------------+

MODIFICA COME INTERVALLO

CAST(expression AS INTERVAL)

Descrizione

BigQuery supporta la trasmissione in INTERVAL. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

STRING

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
STRINGA	INTERVALLO	Quando si trasmette da una stringa all'altra, la stringa deve essere conforme allo standard ISO 8601 Duration o al formato letterale dell'intervallo 'Y-M D H:M:S.F'. Sono accettati anche i formati letterali a intervalli parziali se non sono ambigui, ad esempio 'H:M:S'. Se l'espressione della stringa non è valida o rappresenta un intervallo che non rientra nell'intervallo minimo/massimo supportato, viene generato un errore.

Esempi

SELECT input, CAST(input AS INTERVAL) AS output
FROM UNNEST([
  '1-2 3 10:20:30.456',
  '1-2',
  '10:20:30',
  'P1Y2M3D',
  'PT10H20M30,456S'
]) input

+--------------------+--------------------+
| input              | output             |
+--------------------+--------------------+
| 1-2 3 10:20:30.456 | 1-2 3 10:20:30.456 |
| 1-2                | 1-2 0 0:0:0        |
| 10:20:30           | 0-0 0 10:20:30     |
| P1Y2M3D            | 1-2 3 0:0:0        |
| PT10H20M30,456S    | 0-0 0 10:20:30.456 |
+--------------------+--------------------+

TRASMETTI COME NUMERICO

CAST(expression AS NUMERIC)

Descrizione

BigQuery supporta la trasmissione in numeri NUMERIC. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

INT64
FLOAT64
NUMERIC
BIGNUMERIC
STRING

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
FLOAT64	NUMERICO	Il numero in virgola mobile si arrotonda per metà allo zero. La trasmissione di `NaN`, `+inf` o `-inf` restituirà un errore. La trasmissione di un valore al di fuori dell'intervallo di `NUMERIC` restituirà un errore di overflow.
STRINGA	NUMERICO	Il valore letterale numerico contenuto in `STRING` non deve superare la precisione o l'intervallo massimo del tipo `NUMERIC`, altrimenti si verifica un errore. Se il numero di cifre dopo la virgola decimale supera nove, il valore risultante per `NUMERIC` verrà arrotondato a mezzo distanza da zero per ottenere nove cifre decimali.

TRASMETTI COME STRINGA

CAST(expression AS STRING [format_clause [AT TIME ZONE timezone_expr]])

Descrizione

BigQuery supporta la trasmissione in STRING. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

INT64
FLOAT64
NUMERIC
BIGNUMERIC
BOOL
BYTES
TIME
DATE
DATETIME
TIMESTAMP
INTERVAL
STRING

Clausola Format

Quando un'espressione di un tipo viene trasmessa a un altro tipo, puoi usare la clausola di formato per fornire istruzioni su come eseguire la trasmissione. Puoi utilizzare la clausola di formato in questa sezione se il tipo di dati expression è uno di questi:

INT64
FLOAT64
NUMERIC
BIGNUMERIC
BYTES
TIME
DATE
DATETIME
TIMESTAMP

La clausola relativa al formato STRING ha un'ulteriore clausola facoltativa, AT TIME ZONE timezone_expr, che puoi utilizzare per specificare un fuso orario specifico da usare durante la formattazione di un elemento TIMESTAMP. Se questa clausola facoltativa non è inclusa durante la formattazione di un elemento TIMESTAMP, viene utilizzato il tuo fuso orario corrente.

Per ulteriori informazioni, consulta i seguenti argomenti:

Formatta i byte come stringa
Formattare data e ora come stringa
Formattare il tipo numerico come stringa

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
FLOAT64	STRINGA	Restituisce una rappresentazione approssimativa della stringa.
BOOL	STRINGA	Restituisce `"true"` se `x` è `TRUE`, `"false"` in caso contrario.
BIT	STRINGA	Restituisce `x` interpretato come STRING UTF-8. Ad esempio, il valore letterale BYTES `b'\xc2\xa9'`, quando viene trasmesso a STRING, viene interpretato come UTF-8 e diventa il carattere Unicode "©". Si verifica un errore se `x` non è valido UTF-8.
TEMPO	STRINGA	La trasmissione da un tipo di ora a una stringa è indipendente dal fuso orario ed è nel formato `HH:MM:SS`.
DATA	STRINGA	La trasmissione da un tipo di data a una stringa è indipendente dal fuso orario ed è nel formato `YYYY-MM-DD`.
DATA/Ora	STRINGA	La trasmissione da un tipo di data e ora a una stringa è indipendente dal fuso orario ed è nel formato `YYYY-MM-DD HH:MM:SS`.
TIMESTAMP	STRINGA	Quando trasmetti da tipi di timestamp a una stringa, il timestamp viene interpretato utilizzando il fuso orario predefinito UTC. Il numero di cifre secondarie generate dipende dal numero di zeri finali nella parte del secondo secondo: la funzione CAST verrà troncata a zero, tre o sei cifre.
INTERVALLO	STRINGA	La trasmissione da un intervallo a una stringa è nel formato `Y-M D H:M:S`.

Esempi

SELECT CAST(CURRENT_DATE() AS STRING) AS current_date

+---------------+
| current_date  |
+---------------+
| 2021-03-09    |
+---------------+

SELECT CAST(CURRENT_DATE() AS STRING FORMAT 'DAY') AS current_day

+-------------+
| current_day |
+-------------+
| MONDAY      |
+-------------+

SELECT CAST(
  TIMESTAMP '2008-12-25 00:00:00+00:00'
  AS STRING FORMAT 'YYYY-MM-DD HH24:MI:SS TZH:TZM') AS date_time_to_string

-- Results depend upon where this query was executed.
+------------------------------+
| date_time_to_string          |
+------------------------------+
| 2008-12-24 16:00:00 -08:00   |
+------------------------------+

SELECT CAST(
  TIMESTAMP '2008-12-25 00:00:00+00:00'
  AS STRING FORMAT 'YYYY-MM-DD HH24:MI:SS TZH:TZM'
  AT TIME ZONE 'Asia/Kolkata') AS date_time_to_string

-- Because the time zone is specified, the result is always the same.
+------------------------------+
| date_time_to_string          |
+------------------------------+
| 2008-12-25 05:30:00 +05:30   |
+------------------------------+

SELECT CAST(INTERVAL 3 DAY AS STRING) AS interval_to_string

+--------------------+
| interval_to_string |
+--------------------+
| 0-0 3 0:0:0        |
+--------------------+

SELECT CAST(
  INTERVAL "1-2 3 4:5:6.789" YEAR TO SECOND
  AS STRING) AS interval_to_string

+--------------------+
| interval_to_string |
+--------------------+
| 1-2 3 4:5:6.789    |
+--------------------+

TRASMETTI COME STRUCT

CAST(expression AS STRUCT)

Descrizione

BigQuery supporta la trasmissione in STRUCT. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

STRUCT

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
STRUCT	STRUCT	Consentito se sono soddisfatte le seguenti condizioni: I due STRUCT hanno lo stesso numero di campi. I tipi di campo STRUCT originali possono essere trasmessi esplicitamente ai corrispondenti tipi di campi STRUCT (come definiti dall'ordine dei campi, non dal nome del campo).

MODIFICA COME ORA

CAST(expression AS TIME [format_clause])

Descrizione

BigQuery supporta la trasmissione in TIME. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

STRING
TIME
DATETIME
TIMESTAMP

Clausola Format

Formattare la stringa come data e ora

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
STRINGA	TEMPO	Durante la trasmissione da una stringa all'altra, la stringa deve essere conforme al formato letterale dell'ora supportato ed è indipendente dal fuso orario. Se l'espressione stringa non è valida o rappresenta un orario non compreso nell'intervallo minimo/massimo supportato, viene generato un errore.

CREA COME TIMESTAMP

CAST(expression AS TIMESTAMP [format_clause [AT TIME ZONE timezone_expr]])

Descrizione

BigQuery supporta la trasmissione in TIMESTAMP. Il parametro expression può rappresentare un'espressione per i seguenti tipi di dati:

STRING
TIME
DATETIME
TIMESTAMP

Clausola Format

Formattare la stringa come data e ora

La clausola del formato TIMESTAMP ha un'ulteriore clausola facoltativa chiamata AT TIME ZONE timezone_expr, che puoi utilizzare per specificare un fuso orario specifico da usare durante la formattazione. Se questa clausola facoltativa non è inclusa, viene utilizzato il fuso orario corrente.

Regole di conversione

Da	To	Regole durante la trasmissione di `x`
STRINGA	TIMESTAMP	Quando trasmetti da una stringa a un timestamp, `string_expression` deve essere conforme ai formati letterali dei timestamp supportati, altrimenti si verifica un errore di runtime. L'elemento `string_expression` può contenere un fuso orario. Se il fuso orario è `string_expression`, tale fuso orario viene utilizzato per la conversione, altrimenti viene utilizzato il fuso orario predefinito UTC. Se la stringa contiene meno di sei cifre, viene ampliata implicitamente. Se l'elemento `string_expression` non è valido, viene generato un errore con più di sei cifre secondarie (ovvero una precisione maggiore di microsecondi) o rappresenta un tempo al di fuori dell'intervallo di timestamp supportato.
DATA	TIMESTAMP	La trasmissione da una data a un timestamp interpreta `date_expression` a partire dalla mezzanotte (inizio della giornata) nel fuso orario predefinito, UTC.
DATA/Ora	TIMESTAMP	La trasmissione da una data/ora a un timestamp interpreta `datetime_expression` nel fuso orario predefinito, UTC. La maggior parte dei valori di data e ora validi ha esattamente un timestamp corrispondente in ogni fuso orario. Tuttavia, esistono alcune combinazioni di valori data/ora validi e di fusi orari con zero o due valori di timestamp corrispondenti. Questo si verifica in un fuso orario in cui gli orologi vengono impostati in avanti o indietro, ad esempio per l'ora legale. Se esistono due timestamp validi, viene utilizzato quello precedente. In assenza di un timestamp valido, la durata dell'intervallo di tempo (in genere un'ora) viene aggiunta al timestamp.

Esempi

L'esempio seguente mostra un timestamp in formato stringa sotto forma di timestamp:

SELECT CAST("2020-06-02 17:00:53.110+00:00" AS TIMESTAMP) AS as_timestamp

-- Results depend upon where this query was executed.
+-----------------------------+
| as_timestamp                |
+-----------------------------+
| 2020-06-03 00:00:53.110 UTC |
+-----------------------------+

I seguenti esempi trasmettono una data e un'ora in formato stringa sotto forma di timestamp. Questi esempi restituiscono lo stesso output dell'esempio precedente.

SELECT CAST("06/02/2020 17:00:53.110" AS TIMESTAMP FORMAT 'MM/DD/YYYY HH:MI:SS' AT TIME ZONE 'America/Los_Angeles') AS as_timestamp

SELECT CAST("06/02/2020 17:00:53.110" AS TIMESTAMP FORMAT 'MM/DD/YYYY HH:MI:SS' AT TIME ZONE '00') AS as_timestamp

SELECT CAST('06/02/2020 17:00:53.110 +00' AS TIMESTAMP FORMAT 'YYYY-MM-DD HH:MI:SS TZH') AS as_timestamp

PARSE_BIGNUMERIC

PARSE_BIGNUMERIC(string_expression)

Descrizione

Converte una stringa in un valore BIGNUMERIC.

Il valore letterale numerico contenuto nella stringa non deve superare la precisione o l'intervallo massimo del tipo BIGNUMERIC, altrimenti si verifica un errore. Se il numero di cifre dopo la virgola decimale supera 38, il valore risultante BIGNUMERIC si arrotonda a mezzo distanza da zero in modo da avere 38 cifre dopo la virgola.


-- This example shows how a string with a decimal point is parsed.
SELECT PARSE_BIGNUMERIC("123.45") AS parsed

+--------+
| parsed |
+--------+
| 123.45 |
+--------+

-- This example shows how a string with an exponent is parsed.
SELECT PARSE_BIGNUMERIC("123.456E37") AS parsed

+-----------------------------------------+
| parsed                                  |
+-----------------------------------------+
| 123400000000000000000000000000000000000 |
+-----------------------------------------+

-- This example shows the rounding when digits after the decimal point exceeds 38.
SELECT PARSE_BIGNUMERIC("1.123456789012345678901234567890123456789") as parsed

+------------------------------------------+
| parsed                                   |
+------------------------------------------+
| 1.12345678901234567890123456789012345679 |
+------------------------------------------+

Questa funzione è simile all'utilizzo della funzione CAST AS BIGNUMERIC, tranne per il fatto che la funzione PARSE_BIGNUMERIC accetta solo input di stringa e consente quanto segue nella stringa:

Spazi tra il segno (+/-) e il numero
Segni (+/-) dopo il numero

Regole per le stringhe di input valide:

Regola	Input di esempio	Output
La stringa può contenere solo cifre, virgole, punti decimali e segni.	"- 12.34567,89.0"	-123456789
I white paper sono consentiti ovunque tranne che tra cifre.	" - 12,345 "	-12,345
Solo cifre e virgole sono consentite prima della virgola decimale.	"12.345.678";	12345678
Sono consentite solo cifre dopo la virgola.	"1,234 "	1,234
Utilizza `E` o `e` per gli esponenti. Dopo il `e`, sono consentiti cifre e un indicatore di segno principale.	" 123,45e-1"	12,345
Se la parte intera non è vuota, deve contenere almeno una cifra.	" 0,12 -"	-0,12
Se la stringa contiene un punto decimale, deve contenere almeno una cifra.	" .1"	0,1
La stringa non può contenere più di un segno.	" 0,5 +"	0,5

Tipo di dati da restituire

BIGNUMERIC

Esempi

Questo esempio mostra un input con spazi prima, dopo e tra il segno e il numero:

SELECT PARSE_BIGNUMERIC("  -  12.34 ") as parsed;

+--------+
| parsed |
+--------+
| -12.34 |
+--------+

Questo esempio mostra un input con un esponente e il segno dopo il numero:

SELECT PARSE_BIGNUMERIC("12.34e-1-") as parsed;

+--------+
| parsed |
+--------+
| -1.234 |
+--------+

Questo esempio mostra un input con più virgole nella parte intera del numero:

SELECT PARSE_BIGNUMERIC("  1,2,,3,.45 + ") as parsed;

+--------+
| parsed |
+--------+
| 123.45 |
+--------+

Questo esempio mostra un input con un punto decimale e nessuna cifra nel numero intero:

SELECT PARSE_BIGNUMERIC(".1234  ") as parsed;

+--------+
| parsed |
+--------+
| 0.1234 |
+--------+

Esempi di input non validi

Questo esempio non è valido perché l'intero numero non contiene cifre:

SELECT PARSE_BIGNUMERIC(",,,.1234  ") as parsed;

Questo esempio non è valido perché ci sono spazi vuoti tra le cifre:

SELECT PARSE_BIGNUMERIC("1  23.4 5  ") as parsed;

Questo esempio non è valido perché il numero è vuoto, ad eccezione di un esponente:

SELECT PARSE_BIGNUMERIC("  e1 ") as parsed;

Questo esempio non è valido perché la stringa contiene più segni:

SELECT PARSE_BIGNUMERIC("  - 12.3 - ") as parsed;

Questo esempio non è valido perché il valore del numero non rientra nell'intervallo di BIGNUMERIC:

SELECT PARSE_BIGNUMERIC("12.34E100 ") as parsed;

Questo esempio non è valido perché la stringa contiene caratteri non validi:

SELECT PARSE_BIGNUMERIC("$12.34") as parsed;

PARSE_NUMERIC

PARSE_NUMERIC(string_expression)

Descrizione

Converte una stringa in un valore NUMERIC.

Il valore letterale numerico contenuto nella stringa non deve superare la precisione o l'intervallo massimo del tipo NUMERIC, altrimenti si verifica un errore. Se il numero di cifre dopo la virgola decimale supera nove, il valore risultante NUMERIC si arrotonda a mezzo distanza da zero in modo da avere nove cifre decimali.


-- This example shows how a string with a decimal point is parsed.
SELECT PARSE_NUMERIC("123.45") AS parsed

+--------+
| parsed |
+--------+
| 123.45 |
+--------+

-- This example shows how a string with an exponent is parsed.
SELECT PARSE_NUMERIC("12.34E27") as parsed

+-------------------------------+
| parsed                        |
+-------------------------------+
| 12340000000000000000000000000 |
+-------------------------------+

-- This example shows the rounding when digits after the decimal point exceeds 9.
SELECT PARSE_NUMERIC("1.0123456789") as parsed

+-------------+
| parsed      |
+-------------+
| 1.012345679 |
+-------------+

L'uso di questa funzione è simile a quello della funzione CAST AS NUMERIC. Tuttavia, la funzione PARSE_NUMERIC accetta solo input di stringa e consente quanto segue nella stringa:

Spazi tra il segno (+/-) e il numero
Segni (+/-) dopo il numero

Regole per le stringhe di input valide:

Regola	Input di esempio	Output
La stringa può contenere solo cifre, virgole, punti decimali e segni.	"- 12.34567,89.0"	-123456789
I white paper sono consentiti ovunque tranne che tra cifre.	" - 12,345 "	-12,345
Solo cifre e virgole sono consentite prima della virgola decimale.	"12.345.678";	12345678
Sono consentite solo cifre dopo la virgola.	"1,234 "	1,234
Utilizza `E` o `e` per gli esponenti. Dopo il `e`, sono consentiti cifre e un indicatore di segno principale.	" 123,45e-1"	12,345
Se la parte intera non è vuota, deve contenere almeno una cifra.	" 0,12 -"	-0,12
Se la stringa contiene un punto decimale, deve contenere almeno una cifra.	" .1"	0,1
La stringa non può contenere più di un segno.	" 0,5 +"	0,5

Tipo di dati da restituire

NUMERIC

Esempi

Questo esempio mostra un input con spazi prima, dopo e tra il segno e il numero:

SELECT PARSE_NUMERIC("  -  12.34 ") as parsed;

+--------+
| parsed |
+--------+
| -12.34 |
+--------+

Questo esempio mostra un input con un esponente e il segno dopo il numero:

SELECT PARSE_NUMERIC("12.34e-1-") as parsed;

+--------+
| parsed |
+--------+
| -1.234 |
+--------+

Questo esempio mostra un input con più virgole nella parte intera del numero:

SELECT PARSE_NUMERIC("  1,2,,3,.45 + ") as parsed;

+--------+
| parsed |
+--------+
| 123.45 |
+--------+

Questo esempio mostra un input con un punto decimale e nessuna cifra nel numero intero:

SELECT PARSE_NUMERIC(".1234  ") as parsed;

+--------+
| parsed |
+--------+
| 0.1234 |
+--------+

Esempi di input non validi

Questo esempio non è valido perché l'intero numero non contiene cifre:

SELECT PARSE_NUMERIC(",,,.1234  ") as parsed;

Questo esempio non è valido perché ci sono spazi vuoti tra le cifre:

SELECT PARSE_NUMERIC("1  23.4 5  ") as parsed;

Questo esempio non è valido perché il numero è vuoto, ad eccezione di un esponente:

SELECT PARSE_NUMERIC("  e1 ") as parsed;

Questo esempio non è valido perché la stringa contiene più segni:

SELECT PARSE_NUMERIC("  - 12.3 - ") as parsed;

Questo esempio non è valido perché il valore del numero non rientra nell'intervallo di BIGNUMERIC:

SELECT PARSE_NUMERIC("12.34E100 ") as parsed;

Questo esempio non è valido perché la stringa contiene caratteri non validi:

SELECT PARSE_NUMERIC("$12.34") as parsed;

SAFE_CAST

SAFE_CAST(expression AS typename [format_clause])

Descrizione

Quando utilizzi CAST, una query può non riuscire se BigQuery non è in grado di eseguire la trasmissione. Ad esempio, la seguente query genera un errore:

SELECT CAST("apple" AS INT64) AS not_a_number;

Se vuoi proteggere le tue query da questi tipi di errori, puoi utilizzare SAFE_CAST. SAFE_CAST è identico a CAST, tranne che restituisce NULL, anziché causare un errore.

SELECT SAFE_CAST("apple" AS INT64) AS not_a_number;

+--------------+
| not_a_number |
+--------------+
| NULL         |
+--------------+

Se trasmetti da byte a stringhe, puoi anche utilizzare la funzione SAFE_CONVERT_BYTES_TO_STRING. Eventuali caratteri UTF-8 non validi vengono sostituiti con il carattere sostitutivo Unicode, U+FFFD. Consulta SAFE_CONVERT_BYTES_TO_STRING per ulteriori informazioni.

Altre funzioni di conversione

Per ulteriori informazioni su queste funzioni di conversione, consulta la documentazione:

Funzione di conversione	Da	To
ARRAY_TO_STRING	ARRAY	STRINGA
BOOLE	JSON	BOOL
DATA	Diversi tipi di dati	DATA
ORA	Diversi tipi di dati	DATA/Ora
FLOAT64	JSON	FLOAT64
FROM_BASE32	STRINGA	BYTE
FROM_BASE64	STRINGA	BIT
FROM_HEX	STRINGA	BIT
INT64	JSON	INT64
PARSE_DATE	STRINGA	DATA
PARSE_DATETIME	STRINGA	DATA/Ora
PARSE_JSON	STRINGA	JSON
PARSE_TIME	STRINGA	TEMPO
PARSE_TIMESTAMP	STRINGA	TIMESTAMP
SAFE_CONVERT_BYTES_TO_STRING	BIT	STRINGA
STRINGA	TIMESTAMP	STRINGA
STRINGA	JSON	STRINGA
ORA	Diversi tipi di dati	TEMPO
TIMESTAMP	Diversi tipi di dati	TIMESTAMP
TO_BASE32	BIT	STRINGA
TO_BASE64	BIT	STRINGA
TO_HEX	BIT	STRINGA
TO_JSON	Tutti i tipi di dati	JSON
TO_JSON_STRING	Tutti i tipi di dati	STRINGA

Clausola Format per CAST

format_clause:
  FORMAT format_model

format_model:
  format_string_expression

La clausola del formato può essere utilizzata in alcune funzioni di CAST. Puoi utilizzare una clausola di formato per fornire istruzioni su come condurre una trasmissione. Ad esempio, potresti indicare a un Cast di convertire una sequenza di byte in una stringa con codifica BASE64 anziché con una codifica con codifica UTF-8.

La clausola del formato include un modello di formato. Il modello di formato può contenere elementi di formato combinati tra loro come stringa di formato.

Formatta i byte come stringa

CAST(bytes_expression AS STRING FORMAT format_string_expression)

Puoi trasmettere una sequenza di byte a una stringa con un elemento formato nella stringa formato. Se i byte non possono essere formattati con un elemento di formato, viene restituito un errore. Se la sequenza di byte è NULL, il risultato è NULL. Gli elementi del formato non sono sensibili alle maiuscole.

Formatta elemento	Resi	Esempio
Esadecimale	Converte una sequenza di byte in una stringa esadecimale.	Ingresso: b'\x00\x01\xEF\xFF' Output: 0001efff
BASE	Converte una sequenza di byte in una stringa codificata BASEX. X rappresenta uno di questi numeri: 2, 8, 16, 32, 64.	Inserisci come BASE8: b'\x02\x11\x3B' Output: 00410473
BASE 64 Mln	Converte una sequenza di byte in una stringa con codifica BASE64 basata su rfc 2045 per MIME. Genera un carattere di nuova riga ("\n") ogni 76 caratteri.	Ingresso: b'\xde\xad\xbe\xef' Output: 3q2+7w==
ASCII	Converte una sequenza di byte, che sono valori ASCII, in una stringa. Se l'input contiene byte che non sono una codifica ASCII valida, viene restituito un errore.	Ingresso: b'\x48\x65\x6c\x6c\x6f' Uscita: Hello
UTF-8	Converte una sequenza di byte in valori UTF-8 in una stringa. Se l'input contiene byte che non sono una codifica UTF-8 valida, viene restituito un errore.	Ingresso: b'\x24' Output: $
UTF8	Stesso comportamento di UTF-8.

Tipo di reso

STRING

Esempio

SELECT CAST(b'\x48\x65\x6c\x6c\x6f' AS STRING FORMAT 'ASCII') AS bytes_to_string;

+-----------------+
| bytes_to_string |
+-----------------+
| Hello           |
+-----------------+

Formatta la stringa come byte

CAST(string_expression AS BYTES FORMAT format_string_expression)

Puoi trasmettere una stringa ai byte con un elemento di formato nella stringa del formato. Se la stringa non può essere formattata con l'elemento formato, viene restituito un errore. Gli elementi del formato non sono sensibili alle maiuscole.

Nell'espressione stringa, gli spazi, come \n, vengono ignorati se viene utilizzato l'elemento del formato BASE64 o BASE64M.

Formatta elemento	Resi	Esempio
Esadecimale	Converte una stringa con codifica esadecimale in byte. Se l'input contiene caratteri che non fanno parte dell'alfabeto di codifica esadecimale (0~9, senza distinzione tra maiuscole e minuscole), viene restituito un errore.	Ingresso: '0001efff' Output: b'\x00\x01\xEF\xFF'
BASE	Converte una stringa codificata BASEX in byte. X rappresenta uno di questi numeri: 2, 8, 16, 32, 64. Viene restituito un errore se l'input contiene caratteri che non fanno parte dell'alfabeto di codifica BASEX, ad eccezione dei caratteri di spazio vuoto se l'elemento del formato è BASE64.	Inserisci come BASE8: '00410473' Output: b'\x02\x11\x3B'
BASE 64 Mln	Converte una stringa codificata BASE64 in byte. Se l'input contiene caratteri che non sono spazi vuoti e che non fanno parte dell'alfabeto di codifica BASE64 definito in rfc 2045, viene restituito un errore. La decodifica BASE64M e BASE64 ha lo stesso comportamento.	Input: '3q2+7w==' Output: b'\xde\xad\xbe\xef'
ASCII	Converte una stringa con solo caratteri ASCII in byte. Se l'input contiene caratteri non ASCII, viene restituito un errore.	Ingresso: 'Hello' Output: b'\x48\x65\x6c\x6c\x6f'
UTF-8	Converte una stringa in una sequenza di byte UTF-8.	Ingresso: '$' Output: b'\x24'
UTF8	Stesso comportamento di UTF-8.

Tipo di reso

BYTES

Esempio

SELECT CAST('Hello' AS BYTES FORMAT 'ASCII') AS string_to_bytes

+-------------------------+
| string_to_bytes         |
+-------------------------+
| b'\x48\x65\x6c\x6c\x6f' |
+-------------------------+

Formattare data e ora come stringa

Puoi formattare queste parti di data e ora come stringa:

Formattare l'anno come parte
Formattare la parte del mese come stringa
Formattare la parte del giorno come stringa
Formattare l'ora come stringa
Formattare la parte dei minuti come stringa
Formattare la seconda parte come stringa
Formattare l'indicatore meridiano come stringa
Formattare il fuso orario come stringa
Formatta come valore letterale come stringa

La corrispondenza con maiuscole/minuscole è supportata quando formatti alcune parti di data o ora come stringa e l'output contiene lettere. Per scoprire di più, consulta la corrispondenza delle richieste.

Corrispondenza delle richieste

Quando l'output di alcuni elementi di formato contiene lettere, le lettere maiuscole/minuscole dell'output vengono abbinate alle maiuscole/minuscole dell'elemento di formato, il che significa che le parole nell'output sono in maiuscolo in base a come l'elemento del formato è in maiuscolo. Questa operazione è detta "corrispondenza delle richieste". Le regole sono:

Se le prime due lettere dell'elemento sono entrambe maiuscole, le parole nell'output sono in maiuscolo. Ad esempio DAY = THURSDAY.
Se la prima lettera dell'elemento è in maiuscolo e la seconda in lettere minuscole, la prima lettera di ogni parola nell'output è in maiuscolo e le altre lettere sono minuscole. Ad esempio Day = Thursday.
Se la prima lettera dell'elemento è in lettere minuscole, tutte le lettere nell'output sono in minuscolo. Ad esempio, day = thursday.

Formattare la parte dell'anno come stringa

CAST(expression AS STRING FORMAT format_string_expression)

Trasmetti un tipo di dati contenente l'anno in una stringa. Include elementi di formato che forniscono istruzioni su come condurre il cast.

expression: questa espressione contiene il tipo di dati con l'anno che devi formattare.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento di formato dell'anno.

Questi tipi di dati includono la parte dell'anno:

DATE
DATETIME
TIMESTAMP

Se expression o format_string_expression è NULL, il valore restituito è NULL. Se format_string_expression è una stringa vuota, l'output è una stringa vuota. Se un valore che non è un elemento di formato supportato viene visualizzato in format_string_expression o expression non contiene un valore specificato da un elemento di formato, viene generato un errore.

Formatta elemento	Resi	Esempio
AAAA	Anno, 4 o più cifre.	Ingresso: DATE '2018-01-30' Output: 2018 Ingresso: DATE '76-01-30' Output: 0076 Ingresso: DATE '10000-01-30'
su base annua	Anno, ultime 3 cifre.	Ingresso: DATE '2018-01-30' Output: 018 Ingresso: DATE '98-01-30' Output: 098
su base annua	Anno, ultime 2 cifre.	Ingresso: DATE '2018-01-30' Output: 18 Ingresso: DATE '8-01-30' Output: 08
A	Anno, ultima cifra.	Ingresso: DATE '2018-01-30' Output: 8
RRRR	Stesso comportamento di AAAA.
RR	Stesso comportamento di YY.

Tipo di reso

STRING

Esempio

SELECT CAST(DATE '2018-01-30' AS STRING FORMAT 'YYYY') AS date_time_to_string;

+---------------------+
| date_time_to_string |
+---------------------+
| 2018                |
+---------------------+

Formattare la parte del mese come stringa

CAST(expression AS STRING FORMAT format_string_expression)

Trasmetti un tipo di dati contenente la parte del mese a una stringa. Include elementi di formato che forniscono istruzioni su come condurre il cast.

expression: questa espressione contiene il tipo di dati con il mese che devi formattare.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento formato mese.

Questi tipi di dati includono una parte del mese:

DATE
DATETIME
TIMESTAMP

Formatta elemento	Resi	Esempio
MM	Mese, 2 cifre.	Ingresso: DATE '2018-01-30' Output: 01
LUN	Nome abbreviato di 3 caratteri del mese. I nomi dei mesi abbreviati per le impostazioni internazionali in inglese sono: JAN, FEB, MAR, APRI, MAY, JUN, JUL, AGO, SEP, OTT, NOV, DIC. È supportata la corrispondenza delle richieste.	Ingresso: DATE '2018-01-30' Output: JAN
MESE	Nome del mese. La corrispondenza delle richieste è supportata.	Ingresso: DATE '2018-01-30' Output: GENNAIO

Tipo di reso

STRING

Esempio

SELECT CAST(DATE '2018-01-30' AS STRING FORMAT 'MONTH') AS date_time_to_string;

+---------------------+
| date_time_to_string |
+---------------------+
| JANUARY             |
+---------------------+

Formattare la parte del giorno come stringa

CAST(expression AS STRING FORMAT format_string_expression)

Trasmetti un tipo di dati contenente la parte del giorno a una stringa. Include elementi di formato che forniscono istruzioni su come condurre il cast.

expression: questa espressione contiene il tipo di dati con il giorno in cui devi formattare.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento formato giorno.

Questi tipi di dati includono una parte giornaliera:

DATE
DATETIME
TIMESTAMP

Formatta elemento	Resi	Esempio
GIORNO	Nome del giorno della settimana, localizzato. Gli spazi sono riempiti sul lato destro per raggiungere esattamente la dimensione di output. La corrispondenza delle richieste è supportata.	Ingresso: DATE '2020-12-31' Output: THURSDAY
DY	Nome abbreviato di 3 caratteri del giorno feriale, localizzato. I nomi dei giorni feriali abbreviati per le impostazioni internazionali in inglese sono: MON, TUE, MED, THU, FRI, SAT, SUN. La corrispondenza delle richieste è supportata.	Ingresso: DATE '2020-12-31' Output: THU
D	Il giorno della settimana (da 1 a 7) che inizia con domenica 1.	Ingresso: DATE '2020-12-31' Output: 4
DD	Il giorno del mese di 2 cifre.	Ingresso: DATE '2018-12-02' Output: 02
DDP	Il giorno dell'anno a tre cifre.	Ingresso: DATE '2018-02-03' Output: 034

Tipo di reso

STRING

Esempio

SELECT CAST(DATE '2018-02-15' AS STRING FORMAT 'DD') AS date_time_to_string;

+---------------------+
| date_time_to_string |
+---------------------+
| 15                  |
+---------------------+

Formatta parte dell'ora come stringa

CAST(expression AS STRING FORMAT format_string_expression)

Trasmetti un tipo di dati contenente la parte oraria a una stringa. Include elementi di formato che forniscono istruzioni su come condurre il cast.

expression: questa espressione contiene il tipo di dati con l'ora che devi formattare.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento formato ora.

Questi tipi di dati includono una parte relativa all'ora:

TIME
DATETIME
TIMESTAMP

Formatta elemento	Resi	Esempio
HH	Ora del giorno, formato 12 ore, 2 cifre.	Ingresso: TIME '21:30:00' Output: 09
HH12	Ora del giorno, formato 12 ore.	Ingresso: TIME '21:30:00' Output: 09
HH24	Ora del giorno, formato 24 ore, 2 cifre.	Ingresso: TIME '21:30:00' Uscita: 21

Tipo di reso

STRING

Esempi

SELECT CAST(TIME '21:30:00' AS STRING FORMAT 'HH24') AS date_time_to_string;

+---------------------+
| date_time_to_string |
+---------------------+
| 21                  |
+---------------------+

SELECT CAST(TIME '21:30:00' AS STRING FORMAT 'HH12') AS date_time_to_string;

+---------------------+
| date_time_to_string |
+---------------------+
| 09                  |
+---------------------+

Formatta parte dei minuti come stringa

CAST(expression AS STRING FORMAT format_string_expression)

Trasmetti un tipo di dati contenente la parte minuti a una stringa. Include elementi di formato che forniscono istruzioni su come condurre il cast.

expression: questa espressione contiene il tipo di dati con il minuto da formattare.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento formato minuto.

Questi tipi di dati includono una parte relativa a un minuto:

TIME
DATETIME
TIMESTAMP

Formatta elemento	Resi	Esempio
MI	Minuto, 2 cifre.	Ingresso: TIME '01:02:03' Uscita: 02

Tipo di reso

STRING

Esempio

SELECT CAST(TIME '21:30:00' AS STRING FORMAT 'MI') AS date_time_to_string;

+---------------------+
| date_time_to_string |
+---------------------+
| 30                  |
+---------------------+

Formattare la seconda parte come stringa

CAST(expression AS STRING FORMAT format_string_expression)

Trasmetti un tipo di dati contenente la seconda parte a una stringa. Include elementi di formato che forniscono istruzioni su come condurre il cast.

expression: questa espressione contiene il tipo di dati con il secondo che devi formattare.
format_string_expression: una stringa che contiene elementi di formato, incluso il secondo elemento di formato.

Questi tipi di dati includono una seconda parte:

TIME
DATETIME
TIMESTAMP

Formatta elemento	Resi	Esempio
SS	Secondi del minuto, 2 cifre.	Ingresso: TIME '01:02:03' Uscita: 03
SSSSS	Secondi del giorno, 5 cifre.	Ingresso: TIME '01:02:03' Uscita: 03723
FFN	Frazione del secondo, lunga `n` cifre. Sostituisci `n` con un valore compreso tra 1 e 9. ad esempio FF5. La parte frazionaria del secondo viene arrotondata per adattarla alle dimensioni dell'output.	Input per FF1: TIME '01:05:07.16' Output: 1 Ingresso per FF2: TIME '01:05:07.16' Output: 16 Ingresso per FF3: TIME '01:05:07;

Tipo di reso

STRING

Esempi

SELECT CAST(TIME '21:30:25.16' AS STRING FORMAT 'SS') AS date_time_to_string;

+---------------------+
| date_time_to_string |
+---------------------+
| 25                  |
+---------------------+

SELECT CAST(TIME '21:30:25.16' AS STRING FORMAT 'FF2') AS date_time_to_string;

+---------------------+
| date_time_to_string |
+---------------------+
| 16                  |
+---------------------+

Formattare la parte dell'indicatore meridiano come stringa

CAST(expression AS STRING FORMAT format_string_expression)

Trasmetti un tipo di dati che contiene la parte dell'indicatore meridiano a una stringa. Include elementi di formato che forniscono istruzioni su come condurre il cast.

expression: questa espressione contiene il tipo di dati con l'indicatore meridiano che devi formattare.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento formato dell'indicatore meridiano.

Questi tipi di dati includono una parte dell'indicatore meridiano:

TIME
DATETIME
TIMESTAMP

Formatta elemento	Resi	Esempio
AM	A.M. se il tempo è minore di 12, in caso contrario	Input per A.M.: TIME '01:02:03' Output: A.M. Input per A.M.: TIME '16:02:03' Output: P.M. Input per la mattina: TIME '01:02:03' Output: a-m. Input per la mattina: TIME '01:02:03' Output: a.m.
AM	AM se l'ora è inferiore a 12, altrimenti PM. L'uso delle maiuscole e delle minuscole nell'output è determinato dalla lettera iniziale dell'elemento di formato.	Ingresso per AM: TIME '01:02:03' Output: AM Ingresso per AM: TIME '16:02:03' Uscita: PM Ingresso per am: TIME '01:02:03' Uscita: am; Ingresso: AM
P.M.	L'output è lo stesso dell'elemento del formato A.M.
PM	L'output è uguale all'elemento del formato AM.

Tipo di reso

STRING

Esempi

SELECT CAST(TIME '21:30:00' AS STRING FORMAT 'AM') AS date_time_to_string;
SELECT CAST(TIME '21:30:00' AS STRING FORMAT 'PM') AS date_time_to_string;

+---------------------+
| date_time_to_string |
+---------------------+
| PM                  |
+---------------------+

SELECT CAST(TIME '01:30:00' AS STRING FORMAT 'AM') AS date_time_to_string;
SELECT CAST(TIME '01:30:00' AS STRING FORMAT 'PM') AS date_time_to_string;

+---------------------+
| date_time_to_string |
+---------------------+
| AM                  |
+---------------------+

Formattare la parte del fuso orario come stringa

CAST(expression AS STRING FORMAT format_string_expression)

Trasmetti un tipo di dati contenente la parte del fuso orario a una stringa. Include elementi di formato che forniscono istruzioni su come condurre il cast.

expression: questa espressione contiene il tipo di dati con il fuso orario che devi formattare.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento del formato del fuso orario.

Questi tipi di dati includono una parte del fuso orario:

DATE
TIME
DATETIME
TIMESTAMP

Formatta elemento	Resi	Esempio
TZH	Offset ora per un fuso orario. Sono inclusi il simbolo `+/-` e l'ora di 2 cifre.	Inputstamp: TIMESTAMP '2008-12-25 05:30:00+00' Output: −08
TZM	Differenza di minuto per un fuso orario. Sono inclusi solo i due minuti.	Inputstamp: TIMESTAMP '2008-12-25 05:30:00+00' Output: 00

Tipo di reso

STRING

Esempi

SELECT CAST(TIMESTAMP '2008-12-25 00:00:00+00:00' AS STRING FORMAT 'TZH') AS date_time_to_string;

-- Results depend upon where this query was executed.
+---------------------+
| date_time_to_string |
+---------------------+
| -08                 |
+---------------------+

SELECT CAST(TIMESTAMP '2008-12-25 00:00:00+00:00' AS STRING FORMAT 'TZH' AT TIME ZONE 'Asia/Kolkata')
AS date_time_to_string;

-- Because the time zone is specified, the result is always the same.
+---------------------+
| date_time_to_string |
+---------------------+
| +05                 |
+---------------------+

SELECT CAST(TIMESTAMP '2008-12-25 00:00:00+00:00' AS STRING FORMAT 'TZM') AS date_time_to_string;

-- Results depend upon where this query was executed.
+---------------------+
| date_time_to_string |
+---------------------+
| 00                  |
+---------------------+

SELECT CAST(TIMESTAMP '2008-12-25 00:00:00+00:00' AS STRING FORMAT 'TZM' AT TIME ZONE 'Asia/Kolkata')
AS date_time_to_string;

-- Because the time zone is specified, the result is always the same.
+---------------------+
| date_time_to_string |
+---------------------+
| 30                  |
+---------------------+

Formatta il valore letterale come stringa

CAST(expression AS STRING FORMAT format_string_expression)

Formatta elemento	Resi	Esempio
-	L'output è lo stesso dell'input.	-
.	L'output è lo stesso dell'input.	.
/	L'output è lo stesso dell'input.	/
,	L'output è lo stesso dell'input.	,
".	L'output è lo stesso dell'input.	".
;	L'output è lo stesso dell'input.	;
:	L'output è lo stesso dell'input.	:
Spazio vuoto	L'output è lo stesso dell'input. Per spazio vuoto si intende il carattere dello spazio, ASCII 32. non significa altri tipi di spazio, come una scheda o una nuova riga. Qualsiasi carattere di spazio vuoto diverso dal carattere ASCII 32 nel modello di formato genera un errore.
"testo"	Output corrisponde al valore tra virgolette doppie. Per mantenere una virgoletta doppia o una barra rovesciata, utilizza la sequenza di escape `\"` o `\\`. Non sono supportate altre sequenze di escape.	Ingresso: "abc" Output: abc Ingresso: "a\"b\\c" Output: a"b\c

Formatta la stringa come data e ora

Puoi formattare una stringa con queste parti di data e ora:

Formattare la stringa come parte dell'anno
Formattare la stringa come parte del mese
Formattare la stringa come parte del giorno
Formattare la stringa come parte dell'ora
Formattare la stringa come parte dei minuti
Formattare la stringa come seconda parte
Formattare la stringa come parte dell'indicatore del meridiano
Formattare la stringa come parte del fuso orario
Formattare la stringa come parte letterale

Quando formatti una stringa con parti di data e ora, devi seguire le regole per il formato del modello.

Formattare le regole del modello

Quando trasmetti una stringa a parti con data e ora, devi assicurarti che il modello di formato sia valido. Il modello di formato rappresenta gli elementi trasferiti in CAST(string_expression AS type FORMAT format_string_expression) come format_string_expression e viene convalidato in base alle seguenti regole:

Contiene al massimo una di queste parti: indicatore meridiano, anno, mese, giorno, ora.
Un elemento in formato non letterale e non vuoto non può essere visualizzato più di una volta.
Se contiene l'elemento del formato del giorno dell'anno, DDD non può contenere il mese.
Se contiene l'elemento di formato 24 ore, HH24, non può contenere l'elemento di formato 12 ore o un indicatore meridiano.
Se contiene l'elemento di formato 12 ore, HH12 o HH, deve anche contenere un indicatore di meridiano.
Se contiene un indicatore di meridiano, deve contenere anche un elemento di formato 12 ore.
Se contiene il secondo elemento del formato del giorno, SSSSS, non può contenere i seguenti indicatori: ora, minuto, secondo o meridiano.
Non può contenere un elemento di formato in modo che il valore impostato non esista nel tipo di target. Ad esempio, un elemento in formato ora come HH24 non può apparire in una stringa che trasmetti come DATE.

Formatta la stringa come parte dell'anno

CAST(string_expression AS type FORMAT format_string_expression)

Trasmetti un anno in formato stringa a un tipo di dati contenente la parte dell'anno. Include gli elementi del formato, che forniscono le istruzioni su come condurre il cast.

string_expression: questa espressione contiene la stringa con l'anno che devi formattare.
type: il tipo di dati a cui trasmetti contenuti. Deve includere la parte dell'anno.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento di formato dell'anno. Gli elementi dei formati in questa stringa sono definiti collettivamente come il modello di formato, che deve seguire queste regole.

Questi tipi di dati includono la parte dell'anno:

DATE
DATETIME
TIMESTAMP

Se la parte YEAR non è presente in string_expression e il tipo di reso include questa parte, YEAR è impostato sull'anno corrente.

Se un valore che non è un elemento di formato supportato viene visualizzato in format_string_expression o string_expression non contiene un valore specificato da un elemento di formato, viene generato un errore.

Formatta elemento	Resi	Esempio
AAAA	Se è delimitato, corrisponde a 1-5 cifre. Se non è delimitato, corrisponde a 4 cifre. Imposta la parte dell'anno sul numero corrispondente.	Input per MM-GG-AAAA: '03-12-2018' Output come DATE: 2018-12-03 Ingresso per AAAA-MMGG: '10000-1203' Output come DATE: 10000-12
su base annua	Corrisponde a 3 cifre. Imposta le ultime tre cifre dell'anno sul numero corrispondente.	Input per YYY-MM-GG: '018-12-03' Output come DATE: 2018-12-03 Input per YYY-MM-DD: '038-12-03' Output come DATE: 2038-12
su base annua	Corrisponde a 2 cifre. Imposta le ultime due cifre dell'anno sul numero corrispondente.	Input per YY-MM-GG: '18-12-03' Output come DATE: 2018-12-03 Input per YY-MM-DD: '38-12-03' Output come DATE: 2038-12-03
A	Corrisponde a 1 cifra. Imposta l'ultima cifra dell'anno sull'importo corrispondente.	Ingresso per Y-MM-GG: '8-12-03' Output come DATE: 03-12-2008
Y,YYY	Corrisponde al pattern da 1 a 2 cifre, virgola, quindi esattamente 3 cifre. Imposta la parte dell'anno sul numero corrispondente.	Input per Y,YYY-MM-DD: '2,018-12-03' Output come DATE: 03-12-2008
RRRR	Stesso comportamento di AAAA.
RR	Corrisponde a 2 cifre. Se le 2 cifre inserite sono comprese tra 00 e 49 e le ultime due cifre dell'anno corrente sono comprese tra 00 e 49, l'anno restituito ha le stesse prime due cifre dell'anno corrente. Se le ultime 2 cifre dell'anno in corso sono comprese tra 50 e 99, le prime due cifre dell'anno restituito sono superiori a quelle delle prime 2 dell'anno in corso. Se le 2 cifre inserite sono comprese tra 50 e 99 e le ultime 2 cifre dell'anno corrente sono comprese tra 00 e 49, le prime 2 cifre dell'anno restituito sono 1 in meno delle prime 2 cifre dell'anno corrente. Se le ultime 2 cifre dell'anno in corso sono comprese tra 50 e 99, l'anno restituito ha le stesse prime 2 cifre dell'anno in corso.	Input per RR-MM-GG: '18-12-03' Output come DATE: 03-12-2018 (eseguito nell'anno 2021) Output come DATE: 2118-12-03 (eseguito nell'anno 2050) DD2 -2: -2: -2 -2 -2: 0- _2 non incluso nella data di inizio: 2

Tipo di reso

Il tipo di dati a cui la stringa è stata trasmessa. Le opzioni possibili sono:

DATE
DATETIME
TIMESTAMP

Esempi

SELECT CAST('18-12-03' AS DATE FORMAT 'YY-MM-DD') AS string_to_date

+----------------+
| string_to_date |
+----------------+
| 2018-02-03     |
+----------------+

Formattare la stringa come parte del mese

CAST(string_expression AS type FORMAT format_string_expression)

Trasmetti un mese in formato stringa a un tipo di dati contenente la parte del mese. Include gli elementi del formato, che forniscono le istruzioni su come condurre il cast.

string_expression: questa espressione contiene la stringa con il mese che devi formattare.
type: il tipo di dati a cui trasmetti contenuti. Deve includere la parte del mese.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento formato mese. Gli elementi dei formati in questa stringa sono definiti collettivamente come il modello di formato, che deve seguire queste regole.

Questi tipi di dati includono una parte del mese:

DATE
DATETIME
TIMESTAMP

Se la parte MONTH non è presente in string_expression e il tipo di reso include questa parte, MONTH è impostato sul mese corrente.

Formatta elemento	Resi	Esempio
MM	Corrisponde a 2 cifre. Imposta la parte del mese sul numero corrispondente.	Ingresso per MM-GG-AAAA: '03-12-2018' Output come DATE: 03-12-2018
LUN	Corrisponde a 3 lettere. Imposta la parte del mese sulla stringa con corrispondenza interpretata come nome abbreviato del mese.	Input per MON DD, YYYY: '3 DEC 2018' Output come DATE: 03-12-2018
MESE	Corrisponde a 9 lettere. Imposta la parte del mese sulla stringa con corrispondenza interpretata come nome del mese.	Input per il giorno DD MONTH AAAA: '03 DICEMBRE 2018' Output come DATE: 03-12-2018

Tipo di reso

Il tipo di dati a cui la stringa è stata trasmessa. Le opzioni possibili sono:

DATE
DATETIME
TIMESTAMP

Esempi

SELECT CAST('DEC 03, 2018' AS DATE FORMAT 'MON DD, YYYY') AS string_to_date

+----------------+
| string_to_date |
+----------------+
| 2018-12-03     |
+----------------+

Formattare la stringa come parte del giorno

CAST(string_expression AS type FORMAT format_string_expression)

Trasmetti un giorno in formato stringa a un tipo di dati contenente la parte del giorno. Include gli elementi del formato, che forniscono le istruzioni su come condurre il cast.

string_expression: questa espressione contiene la stringa con il giorno che devi formattare.
type: il tipo di dati a cui trasmetti contenuti. Deve includere la fascia oraria.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento formato giorno. Gli elementi dei formati in questa stringa sono definiti collettivamente come il modello di formato, che deve seguire queste regole.

Questi tipi di dati includono una parte giornaliera:

DATE
DATETIME
TIMESTAMP

Se la parte DAY non è presente in string_expression e il tipo di reso include questa parte, DAY è impostato su 1.

Formatta elemento	Resi	Esempio
DD	Corrisponde a 2 cifre. Imposta la parte del giorno sul numero corrispondente.	Input per il giorno DD MONTH AAAA: '03 DICEMBRE 2018' Output come DATE: 03-12-2018

Tipo di reso

Il tipo di dati a cui la stringa è stata trasmessa. Le opzioni possibili sono:

DATE
DATETIME
TIMESTAMP

Esempi

SELECT CAST('DECEMBER 03, 2018' AS DATE FORMAT 'MONTH DD, YYYY') AS string_to_date

+----------------+
| string_to_date |
+----------------+
| 2018-12-03     |
+----------------+

Formatta la stringa come parte dell'ora

CAST(string_expression AS type FORMAT format_string_expression)

Trasmetti un'ora in formato stringa a un tipo di dati contenente la parte relativa all'ora. Include gli elementi del formato, che forniscono le istruzioni su come condurre il cast.

string_expression: questa espressione contiene la stringa con l'ora che devi formattare.
type: il tipo di dati a cui trasmetti contenuti. Deve includere la parte oraria.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento formato ora. Gli elementi dei formati in questa stringa sono definiti collettivamente come il modello di formato, che deve seguire queste regole.

Questi tipi di dati includono una parte relativa all'ora:

TIME
DATETIME
TIMESTAMP

Se la parte HOUR non è presente in string_expression e il tipo di reso include questa parte, HOUR è impostato su 0.

Formatta elemento	Resi	Esempio
HH	Corrisponde a 2 cifre. Se il numero corrispondente di `n` è `12`, imposta `temp = 0`, altrimenti imposta `temp = n`. Se il valore di corrispondenza dell'elemento del formato A.M./P.M. è P.M., imposta `temp = n + 12`. Imposta la parte dell'ora su `temp`. Quando è presente il codice HH, è necessario un indicatore meridiano nel modello di formato.	Ingresso per HH:MI P.M.: '03:30 PM' Output come ORA: 15:30:00
HH12	Stesso comportamento di HH.
HH24	Corrisponde a 2 cifre. Imposta la parte oraria sul numero corrispondente.	Ingresso per HH24:MI: '15:30' Output come ORA: 15:30:00

Tipo di reso

Il tipo di dati a cui la stringa è stata trasmessa. Le opzioni possibili sono:

TIME
DATETIME
TIMESTAMP

Esempi

SELECT CAST('15:30' AS TIME FORMAT 'HH24:MI') AS string_to_date_time

+---------------------+
| string_to_date_time |
+---------------------+
| 15:30:00            |
+---------------------+

Formatta la stringa come parte dei minuti

CAST(string_expression AS type FORMAT format_string_expression)

Trasmetti un minuto in formato stringa a un tipo di dati contenente la parte relativa ai minuti. Include gli elementi del formato, che forniscono le istruzioni su come condurre il cast.

string_expression: questa espressione contiene la stringa con il minuto da formattare.
type: il tipo di dati a cui trasmetti contenuti. Deve includere la parte in minuti.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento formato minuto. Gli elementi dei formati in questa stringa sono definiti collettivamente come il modello di formato, che deve seguire queste regole.

Questi tipi di dati includono una parte relativa a un minuto:

TIME
DATETIME
TIMESTAMP

Se la parte MINUTE non è presente in string_expression e il tipo di reso include questa parte, MINUTE è impostato su 0.

Formatta elemento	Resi	Esempio
MI	Corrisponde a 2 cifre. Imposta la parte dei minuti sul numero corrispondente.	Ingresso per HH:MI P.M.: '03:30 PM' Output come ORA: 15:30:00

Tipo di reso

Il tipo di dati a cui la stringa è stata trasmessa. Le opzioni possibili sono:

TIME
DATETIME
TIMESTAMP

Esempi

SELECT CAST('03:30 P.M.' AS TIME FORMAT 'HH:MI P.M.') AS string_to_date_time

+---------------------+
| string_to_date_time |
+---------------------+
| 15:30:00            |
+---------------------+

Formattare la stringa come seconda parte

CAST(string_expression AS type FORMAT format_string_expression)

Trasmetti un secondo in formato stringa a un tipo di dati contenente la seconda parte. Include gli elementi del formato, che forniscono le istruzioni su come condurre il cast.

string_expression: questa espressione contiene la stringa con il secondo da formattare.
type: il tipo di dati a cui trasmetti contenuti. Deve includere la seconda parte.
format_string_expression: una stringa che contiene elementi di formato, incluso il secondo elemento di formato. Gli elementi dei formati in questa stringa sono definiti collettivamente come il modello di formato, che deve seguire queste regole.

Questi tipi di dati includono una seconda parte:

TIME
DATETIME
TIMESTAMP

Se la parte SECOND non è presente in string_expression e il tipo di reso include questa parte, SECOND è impostato su 0.

Formatta elemento	Resi	Esempio
SS	Corrisponde a 2 cifre. Imposta la seconda parte sul numero corrispondente.	Input per HH:MI:SS P.M.: '03:30:02 PM' Output come ORA: 15:30:02
SSSSS	Corrisponde a 5 cifre. Imposta le parti di ore, minuti e secondi interpretando il numero corrispondente come il numero di secondi dopo la mezzanotte.	Input per SSSSS: '03723' Output come TIME: 01:02:03
FFN	Corrisponde a `n` cifre, dove `n` è il numero successivo a FF nell'elemento del formato. Imposta la parte frazionaria della seconda parte sul numero corrispondente.	Input per HH24:MI:SS.FF1: '01:05:07.16' Output come TIME: 01:05:07.2 Input per HH24:MI:SS.FF2: '01:05:07.16' 1:0: 0: 0: 0:8: 0: 0: 0:8

Tipo di reso

Il tipo di dati a cui la stringa è stata trasmessa. Le opzioni possibili sono:

TIME
DATETIME
TIMESTAMP

Esempi

SELECT CAST('01:05:07.16' AS TIME FORMAT 'HH24:MI:SS.FF1') AS string_to_date_time

+---------------------+
| string_to_date_time |
+---------------------+
| 01:05:07.2          |
+---------------------+

Formatta la stringa come parte dell'indicatore del meridiano

CAST(string_expression AS type FORMAT format_string_expression)

Trasmetti un indicatore di meridiano formattato come stringa a un tipo di dati contenente la parte dell'indicatore di meridiano. Include gli elementi del formato, che forniscono le istruzioni su come condurre il cast.

string_expression: questa espressione contiene la stringa con l'indicatore meridiano da formattare.
type: il tipo di dati a cui trasmetti contenuti. Deve includere la parte dell'indicatore meridiano.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento formato dell'indicatore meridiano. Gli elementi dei formati in questa stringa sono definiti collettivamente come il modello di formato, che deve seguire queste regole.

Questi tipi di dati includono una parte dell'indicatore meridiano:

TIME
DATETIME
TIMESTAMP

Formatta elemento	Resi	Esempio
AM o P.M.	Corrisponde all'espressione regolare `'(A\|P)\.M\.'`	Ingresso per HH:MI A.M.: '03:30 AM' Output come TIME: 03:30:00 Input per HH:MI P.M.: '03:30 PM' Output come ORA: 15:30:00 Input per HH:MI P.M.: '03:30 AM' Output come TIME: 03:30:00 Input per HH:MI A.M.: '03:30 PM' Output come ORA: 15:30:00 Ingresso per HH:MI a.m.: '03:30' Output come ORA: 03:30:00

Tipo di reso

Il tipo di dati a cui la stringa è stata trasmessa. Le opzioni possibili sono:

TIME
DATETIME
TIMESTAMP

Esempi

SELECT CAST('03:30 P.M.' AS TIME FORMAT 'HH:MI A.M.') AS string_to_date_time

+---------------------+
| string_to_date_time |
+---------------------+
| 15:30:00            |
+---------------------+

Formatta la stringa come parte del fuso orario

CAST(string_expression AS type FORMAT format_string_expression)

Trasmetti un fuso orario in formato stringa a un tipo di dati contenente la parte del fuso orario. Include gli elementi del formato, che forniscono le istruzioni su come condurre il cast.

string_expression: questa espressione contiene la stringa con il fuso orario che devi formattare.
type: il tipo di dati a cui trasmetti contenuti. Deve includere la parte del fuso orario.
format_string_expression: una stringa che contiene elementi di formato, incluso l'elemento del formato del fuso orario. Gli elementi dei formati in questa stringa sono definiti collettivamente come il modello di formato, che deve seguire queste regole.

Questi tipi di dati includono una parte del fuso orario:

DATE
TIME
DATETIME
TIMESTAMP

Formatta elemento	Resi	Esempio
TZH	Corrisponde all'espressione regolare `'(\+\|\-\| )[0-9]{2}'` Imposta il fuso orario e le parti dell'ora sul segno e sul numero corrispondenti. Imposta il segno del fuso orario sulla prima lettera della stringa corrispondente. Il numero 2 significa corrispondere fino a 2 cifre per la corrispondenza non esatta ed esattamente 2 cifre per la corrispondenza esatta.	Input per AAAA-MM-GG HH:MI:SSTZH: '2008-12-25 05:30:00-08' Output come TIMESTAMP: 25-12-2008 05:30:00-08
TZM	Corrisponde a 2 cifre. Lascia che `n` sia il numero corrispondente. Se il segno del fuso orario è il segno meno, imposta la parte dei minuti nel fuso orario su `-n`. In caso contrario, imposta la parte dei fusi orari su `n`.	Input per AAAA-MM-GG HH:MI:SSTZH: '2008-12-25 05:30:00+05.30' Output come TIMESTAMP: 25-12-2008 05:30:00+05.30

Tipo di reso

Il tipo di dati a cui la stringa è stata trasmessa. Le opzioni possibili sono:

DATE
TIME
DATETIME
TIMESTAMP

Esempi

SELECT CAST('2020.06.03 00:00:53+00' AS TIMESTAMP FORMAT 'YYYY.MM.DD HH:MI:SSTZH') AS string_to_date_time

+-----------------------------+
| as_timestamp                |
+-----------------------------+
| 2020-06-03 00:00:53.110 UTC |
+-----------------------------+

Formatta la stringa come valore letterale

CAST(string_expression AS data_type FORMAT format_string_expression)

Formatta elemento	Resi	Esempio
-	L'output è lo stesso dell'input.
.	L'output è lo stesso dell'input.	.
/	L'output è lo stesso dell'input.	/
,	L'output è lo stesso dell'input.	,
".	L'output è lo stesso dell'input.	".
;	L'output è lo stesso dell'input.	;
:	L'output è lo stesso dell'input.	:
Spazio vuoto	Una sequenza consecutiva di uno o più spazi nel modello di formato viene associata a uno o più spazi vuoti Unicode consecutivi. Per spazio si intende il carattere di spazio ASCII 32. Non indica lo spazio vuoto generale, come una scheda o una nuova riga. Qualsiasi carattere di spazio vuoto diverso dal carattere ASCII 32 nel modello di formato genera un errore.
"testo"	Output generato dall'elemento di formato nella formattazione, utilizzando questa espressione regolare, dove `s` rappresenta l'input della stringa: `regex.escape(s)`.	Ingresso: "abc" Output: abc Ingresso: "a\"b\\c" Output: a"b\c

Formattare il tipo numerico come stringa

CAST(numeric_expression AS STRING FORMAT format_string_expression)

Puoi trasmettere un tipo numerico a una stringa combinando i seguenti elementi di formato:

Cifre
Punto decimale
Simbolo
Simbolo di valuta
Separatore gruppo
Altri elementi di formato

Ad eccezione dell'elemento di formato esponente (EEEE), tutti gli elementi di formato generano un numero fisso di caratteri nell'output, che è allineato alla virgola decimale. Il primo carattere restituisce - per i numeri negativi, altrimenti uno spazio. Per eliminare i caratteri vuoti e gli zeri finali, utilizza il flag FM.

Tipo di reso

STRING

Esempio

SELECT input, CAST(input AS STRING FORMAT '$999,999.999') AS output
FROM UNNEST([1.2, 12.3, 123.456, 1234.56, -12345.678, 1234567.89]) AS input

+------------+---------------+
|   input    |    output     |
+------------+---------------+
|        1.2 |        $1.200 |
|       12.3 |       $12.300 |
|    123.456 |      $123.456 |
|    1234.56 |    $1,234.560 |
| -12345.678 |  -$12,345.678 |
| 1234567.89 |  $###,###.### |
+------------+---------------+

Formattare le cifre come stringa

I seguenti elementi di formato contengono cifre di output. Se non ci sono abbastanza elementi di formato cifra per rappresentare l'input, tutti gli elementi di formato numerico vengono sostituiti con # nell'output.

Formatta elemento Resi Esempio

Una cifra decimale. Sono inclusi gli zeri iniziali e finali.

Input: 12
Formato: '000'
Output: ' 012'

Input: 12
Formato: '000.000'
Output: ' 012.000'

Input: -12
Formato: '000.000'
Output: '-012.000'

Una cifra decimale. Gli zeri iniziali vengono sostituiti con gli spazi. Sono inclusi degli zeri finali.

Input: 12
Formato: '999'
Output: ' 12'

Input: 12
Formato: '999.999'
Output: ' 12.000'

X o x

Una cifra esadecimale. Non può essere visualizzato con altri elementi di formato, ad eccezione di 0, FM e gli elementi del formato di firma. Il numero massimo di cifre esadecimali nella stringa di formato è 16.

X genera lettere maiuscole e x genera lettere minuscole.

Quando 0 viene combinato con l'elemento in formato esadecimale, la lettera generata da 0 corrisponde al caso dell'elemento X o x successivo. Se non è presente alcuna X o x successiva, 0 genera una lettera maiuscola.

Input: 43981
Formato: 'XXXX'
Output: ' ABCD'

Input: 43981
Formato: 'xxxx'
Output: ' abcd'

Input: 43981
Formato: '0X0x'
Output: ' ABcd'

Ingresso: 43981
Formato: '0000000X'
Output: ' 0000ABCD'

Tipo di reso

STRING

Esempio

SELECT
  CAST(12 AS STRING FORMAT '999') as a,
  CAST(-12 AS STRING FORMAT '999') as b;

+------+------+
|  a   |  b   |
+------+------+
|   12 |  -12 |
+------+------+

Formatta il punto decimale come stringa

I seguenti elementi di formato restituiscono un punto decimale. Questi elementi di formato si escludono a vicenda. Nella stringa del formato può apparire al massimo uno.

Formatta elemento	Resi	Esempio
. (punto)	Punto decimale.	Input: `123.58` Formato: `'999.999'` Output: `' 123.580'`
D	Il punto decimale delle impostazioni internazionali correnti.	Input: `123.58` Formato: `'999D999'` Output: `' 123.580'`

Tipo di reso

STRING

Esempio

SELECT CAST(12.5 AS STRING FORMAT '99.99') as a;

+--------+
|   a    |
+--------+
|  12.50 |
+--------+

Formattare il simbolo come stringa

I seguenti elementi di formato generano il simbolo (+/-). Questi elementi di formato si escludono a vicenda. Nella stringa del formato può apparire al massimo uno.

Se non sono presenti elementi del formato del simbolo, viene riservato uno spazio aggiuntivo per il simbolo. Ad esempio, se il valore inserito è 12 e la stringa del formato è '99', l'output è ' 12', con una lunghezza di tre caratteri.

Il segno viene visualizzato prima del numero. Se il modello di formato include un elemento di simbolo di valuta, il segno viene visualizzato prima del simbolo di valuta.

Formatta elemento	Resi	Esempio
S	Simbolo esplicito. Restituisce `+` per numeri positivi e `-` per numeri negativi. La posizione nell'output è ancorata al numero.	Input: `-12` Formato: `'S9999'` Output: `' -12'` Input: `-12` Formato: `'9999S'` Output: `' 12-'`
MI	Simbolo esplicito. Restituisce uno spazio per i numeri positivi e `-` per i numeri negativi. Questo elemento può essere visualizzato solo nell'ultima posizione.	Input: `12` Formato: `'9999MI'` Output: `' 12 '` Input: `-12` Formato: `'9999MI'` Output: `' 12-'`
PR	Per i numeri negativi, il valore è racchiuso tra parentesi angolari. Per i numeri positivi, viene restituito il valore con uno spazio iniziale e finale. Questo elemento può essere visualizzato solo nell'ultima posizione.	Input: `12` Formato: `'9999PR'` Output: `' 12 '` Input: `-12` Formato: `'9999PR'` Output: `' <12>'`

Tipo di reso

STRING

Esempio

SELECT
  CAST(12 AS STRING FORMAT 'S99') as a,
  CAST(-12 AS STRING FORMAT 'S99') as b;

+-----+-----+
|  a  |  b  |
+-----+-----+
| +12 | -12 |
+-----+-----+

Formatta il simbolo di valuta come stringa

I seguenti elementi di formato generano un simbolo di valuta. Questi elementi di formato si escludono a vicenda. Nella stringa del formato può apparire al massimo uno. Nell'output, il simbolo di valuta viene visualizzato prima della prima cifra o del punto decimale.

Formatta elemento	Resi	Esempio
$	Simbolo del dollaro ($).	Input: `-12` Formato: `'$999'` Output: `' -$12'`
C o C	Il codice valuta ISO-4217 della lingua corrente.	Input: `-12` Formato: `'C999'` Output: `' -USD12'` Input: `-12` Formato: `'c999'` Output: `' -usd12'`
S	Il simbolo di valuta delle impostazioni internazionali correnti.	Input: `-12` Formato: `'L999'` Output: `' -$12'`

Tipo di reso

STRING

Esempio

SELECT
  CAST(12 AS STRING FORMAT '$99') as a,
  CAST(-12 AS STRING FORMAT '$99') as b;

+------+------+
|  a   |  b   |
+------+------+
|  $12 | -$12 |
+------+------+

Formattare il separatore di gruppo come stringa

I seguenti elementi di formato generano un separatore di gruppo.

Formatta elemento	Resi	Esempio
, (virgola)	Separatore di gruppi.	Input: `12345` Formato: `'999,999'` Output: `' 12,345'`
G	Il punto di separazione del gruppo delle impostazioni internazionali correnti.	Input: `12345` Formato: `'999G999'` Output: `' 12,345'`

Tipo di reso

STRING

Esempio

SELECT CAST(1234 AS STRING FORMAT '999,999') as a;

+----------+
|    a     |
+----------+
|    1,234 |
+----------+

Altri elementi di formato numerico

Formatta elemento	Resi	Esempio
B	Genera spazi quando la parte intera è zero. Se la parte intera del numero è 0, i seguenti elementi di formato generano spazi nell'output: cifre (9, X, 0), punto decimale, separatore di gruppo, valuta, segno ed esponente.	Input: `0.23` Formato: `'B99.999S'` Output: `' '` Input: `1.23` Formato: `'B99.999S'` Output: `' 1.230+'`
EEEE	Visualizza la parte esponente del valore nella notazione scientifica. Se il valore dell'esponente è compreso tra -99 e 99, l'output è quattro caratteri. In caso contrario, nell'output viene utilizzato il numero minimo di cifre.	Input: `20` Formato: `'9.99EEEE'` Output: `' 2.0E+01'` Input: `299792458` Formato: `'S9.999EEEE'` Output: `'+2.998E+08'`
FM	Rimuove tutti gli spazi e gli zeri finali dall'output. Puoi utilizzare questo elemento per eliminare gli spazi e gli zeri finali generati da altri elementi di formato.	Input: `12.5` Formato: `'999999.000FM'` Output: `'12.5'`
N/D	Restituisce il valore in numeri romani, arrotondato al numero intero più vicino. L'input deve essere compreso tra 1 e 3999. L'output è riempito con spazi a sinistra fino a una lunghezza di 15. Questo elemento non può essere utilizzato con altri elementi di formato ad eccezione di `FM`.	Input: `2021` Formato: `'RN'` Output: `' MMXXI'`
V	Il valore di input viene moltiplicato per 10^n, dove n è il numero di 9s dopo `V`. Questo elemento non può essere utilizzato con un punto decimale o un elemento di formato esponente.	Input: `23.5` Formato: `'S000V00'` Output: `'+02350'`

Tipo di reso

STRING

Esempio

SELECT CAST(-123456 AS STRING FORMAT '9.999EEEE') as a;"

+------------+
|     a      |
+------------+
| -1.235E+05 |
+------------+

Informazioni sulla codifica BASE

La codifica BASE traduce i dati binari in formato stringa in una rappresentazione X.

Se X è 2, 8 o 16, nella stringa codificata vengono utilizzati i numeri arabi 0-9 e le lettere latine a-z. Ad esempio, i risultati della codifica BASE16/esadecimale contengono 0~9 e a~f.

Se X è 32 o 64, le tabelle di caratteri predefinite sono definite in rfc 4648. Quando esegui la decodifica di una stringa BASE in cui X è 2, 8 o 16, le lettere latine nella stringa di input non fanno distinzione tra maiuscole e minuscole. Ad esempio, entrambe le stringhe "3a" e "3A" sono stringhe di input valide per la decodifica BASE16/esadecimale e restituiscono lo stesso risultato.

Funzioni matematiche

Tutte le funzioni matematiche hanno i seguenti comportamenti:

Restituisce NULL se uno dei parametri di input è NULL.
Restituisce NaN se uno degli argomenti è NaN.

ABS

ABS(X)

Descrizione

Calcola il valore assoluto. Restituisce un errore se l'argomento è un numero intero e il valore di output non può essere rappresentato nello stesso tipo; ciò si verifica solo per il più grande valore di input negativo, che non ha rappresentazione positiva.

X	ABS(X)
25	25
-25	25
`+inf`	`+inf`
`-inf`	`+inf`

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICO	FLOAT64
USCITA	INT64	NUMERICO	BIGNUMERICA	FLOAT64

FIRMA

SIGN(X)

Descrizione

Restituisce -1, 0 o +1 per argomenti negativi, zero e positivi. Per gli argomenti con rappresentazione in virgola mobile, questa funzione non distingue tra positivi e zero negativi.

X	SIGN(X)
25	+1
0	0
-25	-1
NaN	NaN

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
USCITA	INT64	NUMERICO	BIGNUMERICA	FLOAT64

QI_INF

IS_INF(X)

Descrizione

Restituisce TRUE se il valore è infinito o negativo.

X	IS_INF(X)
`+inf`	`TRUE`
`-inf`	`TRUE`
25	`FALSE`

QI_NAN

IS_NAN(X)

Descrizione

Restituisce TRUE se il valore è NaN.

X	IS_NAN(X)
`NaN`	`TRUE`
25	`FALSE`

EEEE_DIVIDE

IEEE_DIVIDE(X, Y)

Descrizione

Divide X per Y; questa funzione non viene mai annullata. Restituisce FLOAT64. A differenza dell'operatore di divisione (/), questa funzione non genera errori di divisione per zero o di overflow.

X	A	IEEE_DIVIDE(X, Y)
20,0	4.0	5.0
0.0	25,0	0.0
25,0	0.0	`+inf`
-25,0	0.0	`-inf`
0.0	0.0	`NaN`
0.0	`NaN`	`NaN`
`NaN`	0.0	`NaN`
`+inf`	`+inf`	`NaN`
`-inf`	`-inf`	`NaN`

RAND

RAND()

Descrizione

Genera un valore pseudo-casuale di tipo FLOAT64 nell'intervallo [0, 1), compreso da 0 e escluso 1.

SQRT

SQRT(X)

Descrizione

Calcola la radice quadrata di X. Genera un errore se la X è inferiore a 0.

X	SQRT(X)
`25.0`	`5.0`
`+inf`	`+inf`
`X < 0`	Errore

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
USCITA	FLOAT64	NUMERICO	BIGNUMERICO	FLOAT64

POW

POW(X, Y)

Descrizione

Restituisce il valore di X elevato alla potenza di Y. Se il risultato è insufficiente e non è rappresentabile, la funzione restituisce un valore pari a zero.

X	A	POW(X, Y)
2.0	3.0	8,0
1.0	Qualsiasi valore, tra cui `NaN`	1.0
Qualsiasi valore, tra cui `NaN`	0	1.0
-1,0	`+inf`	1.0
-1,0	`-inf`	1.0
ABS(X) < 1	`-inf`	`+inf`
ABS(X) > 1	`-inf`	0.0
ABS(X) < 1	`+inf`	0.0
ABS(X) > 1	`+inf`	`+inf`
`-inf`	Y < 0	0.0
`-inf`	S > 0	`-inf` se Y è un numero intero dispari, `+inf` in caso contrario
`+inf`	Y < 0	0
`+inf`	S > 0	`+inf`
Valore finale < 0	Numero intero	Errore
0	Valore finale < 0	Errore

Tipo di dati da restituire

Il tipo di dati restituito è determinato dai tipi di argomenti con la seguente tabella.

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
INT64	FLOAT64	NUMERICO	BIGNUMERICA	FLOAT64
NUMERICO	NUMERICO	NUMERICO	BIGNUMERICA	FLOAT64
BIGNUMERICO	BIGNUMERICA	BIGNUMERICA	BIGNUMERICA	FLOAT64
FLOAT64	FLOAT64	FLOAT64	FLOAT64	FLOAT64

ALIMENTAZIONE

POWER(X, Y)

Descrizione

Sinonimi di POW(X, Y).

Scad

EXP(X)

Descrizione

Calcola e alla potenza di X, chiamata anche funzione esponenziale naturale. Se il risultato è in corso, questa funzione restituisce uno zero. Genera un errore se il risultato è overflow.

X	EXP(X)
0.0	1.0
`+inf`	`+inf`
`-inf`	0.0

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
USCITA	FLOAT64	NUMERICO	BIGNUMERICO	FLOAT64

PT

LN(X)

Descrizione

Calcola il logaritmo naturale di X. Genera un errore se X è minore o uguale a zero.

X	LN(X)
1.0	0.0
`+inf`	`+inf`
`X < 0`	Errore

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICO	FLOAT64
USCITA	FLOAT64	NUMERICO	BIGNUMERICA	FLOAT64

REGISTRA

LOG(X [, Y])

Descrizione

Se è presente solo X, LOG è sinonimo di LN. Se è presente anche Y, LOG calcola il logaritmo di X per basare Y.

X	A	LOG(X, Y)
100,0	10,0	2.0
`-inf`	Qualsiasi valore	`NaN`
Qualsiasi valore	`+inf`	`NaN`
`+inf`	0.0 < Y < 1.0	`-inf`
`+inf`	Y > 1,0	`+inf`
X <= 0	Qualsiasi valore	Errore
Qualsiasi valore	Y <= 0	Errore
Qualsiasi valore	1.0	Errore

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
INT64	FLOAT64	NUMERICO	BIGNUMERICO	FLOAT64
NUMERICO	NUMERICO	NUMERICO	BIGNUMERICA	FLOAT64
BIGNUMERICA	BIGNUMERICA	BIGNUMERICA	BIGNUMERICO	FLOAT64
FLOAT64	FLOAT64	FLOAT64	FLOAT64	FLOAT64

LOG10

LOG10(X)

Descrizione

È simile a LOG, ma calcola il logaritmo in base 10.

X	LOG10(X)
100,0	2.0
`-inf`	`NaN`
`+inf`	`NaN`
X <= 0	Errore

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
USCITA	FLOAT64	NUMERICO	BIGNUMERICA	FLOAT64

PIÙ OTTIMANO

GREATEST(X1,...,XN)

Descrizione

Restituisce il valore più alto tra X1,...,XN. Se qualsiasi argomento è NULL, restituisce NULL. Altrimenti, nel caso di argomenti in virgola mobile, se qualsiasi argomento è NaN, restituisce NaN. In tutti gli altri casi, restituisce il valore compreso tra X1,...,XN che ha il valore più elevato in base all'ordine utilizzato dalla clausola ORDER BY. Gli argomenti X1, ..., XN devono essere coercibili per un supertipo comune e quest'ultimo deve supportare l'ordinamento.

X1,...,XN	GREATEST(X1;...,XN)
3,5,1	5

Questa funzione supporta la specifica collatura.

Tipi di dati restituiti

Tipo di dati dei valori di input.

MENO

LEAST(X1,...,XN)

Descrizione

Restituisce il valore minimo tra X1,...,XN. Se qualsiasi argomento è NULL, restituisce NULL. Altrimenti, nel caso di argomenti in virgola mobile, se qualsiasi argomento è NaN, restituisce NaN. In tutti gli altri casi, restituisce il valore compreso tra X1,...,XN che ha il valore più basso in base all'ordine utilizzato dalla clausola ORDER BY. Gli argomenti X1, ..., XN devono essere coercibili per un supertipo comune e quest'ultimo deve supportare l'ordinamento.

X1,...,XN	MENO(X1;...,XN)
3,5,1	1

Questa funzione supporta la specifica collatura.

Tipi di dati restituiti

Tipo di dati dei valori di input.

DIV

DIV(X, Y)

Descrizione

Restituisce il risultato della divisione intera di X per Y. La divisione per zero restituisce un errore. La divisione per -1 potrebbe avere un overflow.

X	A	DIV(X, Y)
20	4	5
12	-7	-1
20	3	6
0	20	0
20	0	Errore

Tipo di dati da restituire

Il tipo di dati restituito è determinato dai tipi di argomenti con la seguente tabella.

INGRESSO	INT64	NUMERICO	BIGNUMERICA
INT64	INT64	NUMERICO	BIGNUMERICO
NUMERICO	NUMERICO	NUMERICO	BIGNUMERICA
BIGNUMERICA	BIGNUMERICA	BIGNUMERICA	BIGNUMERICA

SICURO DIVIDE

SAFE_DIVIDE(X, Y)

Descrizione

Equivalente all'operatore di divisione (X / Y), ma restituisce NULL se si verifica un errore, ad esempio una divisione per zero errore.

X	A	SAFE_DIVIDE(X, Y)
20	4	5
0	20	`0`
20	0	`NULL`

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
INT64	FLOAT64	NUMERICO	BIGNUMERICA	FLOAT64
NUMERICO	NUMERICO	NUMERICO	BIGNUMERICA	FLOAT64
BIGNUMERICA	BIGNUMERICA	BIGNUMERICO	BIGNUMERICO	FLOAT64
FLOAT64	FLOAT64	FLOAT64	FLOAT64	FLOAT64

SAFE_MULTIPLY

SAFE_MULTIPLY(X, Y)

Descrizione

Equivalente all'operatore di moltiplicazione (*), ma restituisce NULL se si verifica l'overflow.

X	A	SAFE_MULTIPLY(X, Y)
20	4	80

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICO	FLOAT64
INT64	INT64	NUMERICO	BIGNUMERICA	FLOAT64
NUMERICO	NUMERICO	NUMERICO	BIGNUMERICA	FLOAT64
BIGNUMERICA	BIGNUMERICA	BIGNUMERICA	BIGNUMERICA	FLOAT64
FLOAT64	FLOAT64	FLOAT64	FLOAT64	FLOAT64

NEGOZIO_SICURO

SAFE_NEGATE(X)

Descrizione

Equivalente all'operatore unario meno (-), ma restituisce NULL se si verifica l'overflow.

X	SAFE_NEGATE(X)
+1	-1
-1	+1
0	0

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
USCITA	INT64	NUMERICO	BIGNUMERICA	FLOAT64

SAFE_ADD

SAFE_ADD(X, Y)

Descrizione

Equivalente all'operatore aggiuntivo (+), ma restituisce NULL se si verifica l'overflow.

X	A	SAFE_ADD(X, Y)
5	4	9

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
INT64	INT64	NUMERICO	BIGNUMERICO	FLOAT64
NUMERICO	NUMERICO	NUMERICO	BIGNUMERICO	FLOAT64
BIGNUMERICO	BIGNUMERICA	BIGNUMERICA	BIGNUMERICO	FLOAT64
FLOAT64	FLOAT64	FLOAT64	FLOAT64	FLOAT64

SAFE_SUBTRACT

SAFE_SUBTRACT(X, Y)

Descrizione

Restituisce il risultato di Y sottratto da X. Equivalente all'operatore di sottrazione (-), ma restituisce NULL se si verifica l'overflow.

X	A	SAFE_SUBTRACT(X, Y)
5	4	1

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
INT64	INT64	NUMERICO	BIGNUMERICA	FLOAT64
NUMERICO	NUMERICO	NUMERICO	BIGNUMERICA	FLOAT64
BIGNUMERICA	BIGNUMERICA	BIGNUMERICA	BIGNUMERICA	FLOAT64
FLOAT64	FLOAT64	FLOAT64	FLOAT64	FLOAT64

MOD

MOD(X, Y)

Descrizione

Funzione modulo: restituisce il resto della divisione di X per Y. Il valore restituito ha lo stesso segno di X. Se viene generato 0, viene generato un errore.

X	A	MOD(X; Y)
25	12	1
25	0	Errore

Tipo di dati da restituire

Il tipo di dati restituito è determinato dai tipi di argomenti con la seguente tabella.

INGRESSO	INT64	NUMERICO	BIGNUMERICA
INT64	INT64	NUMERICO	BIGNUMERICA
NUMERICO	NUMERICO	NUMERICO	BIGNUMERICA
BIGNUMERICA	BIGNUMERICA	BIGNUMERICO	BIGNUMERICA

ARROTONDA

ROUND(X [, N])

Descrizione

Se è presente solo X, ROUND arrotonda la cifra X al numero intero più vicino. Se è presente il valore N, ROUND arrotonda alla posizione decimale da X a N dopo la virgola. Se N è negativo, ROUND arrotonda la cifra a sinistra della virgola decimale. Arrotonda a metà i casi da zero. Genera un errore se si verifica l'overflow.

X	ROUND(X)
2.0	2.0
2,3	2.0
2,8	3.0
2,5	3.0
-2,3	-2,0
-2,8	-3,0
-2,5	-3,0
0	0
`+inf`	`+inf`
`-inf`	`-inf`
`NaN`	`NaN`

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICO	FLOAT64
USCITA	FLOAT64	NUMERICO	BIGNUMERICA	FLOAT64

TRUNC

TRUNC(X [, N])

Descrizione

Se è presente solo X, TRUNC arrotonda la cifra X al numero intero più vicino il cui valore assoluto non è maggiore del valore assoluto di X. Se è presente anche N, TRUNC si comporta come ROUND(X, N), ma arrotonda sempre a zero e non esegue mai overflow.

X	TRUNC(X)
2.0	2.0
2,3	2.0
2,8	2.0
2,5	2.0
-2,3	-2,0
-2,8	-2,0
-2,5	-2,0
0	0
`+inf`	`+inf`
`-inf`	`-inf`
`NaN`	`NaN`

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
USCITA	FLOAT64	NUMERICO	BIGNUMERICA	FLOAT64

SECCO

CEIL(X)

Descrizione

Restituisce il valore fondamentale più piccolo che non è inferiore a X.

X	CEIL(X)
2.0	2.0
2,3	3.0
2,8	3.0
2,5	3.0
-2,3	-2,0
-2,8	-2,0
-2,5	-2,0
0	0
`+inf`	`+inf`
`-inf`	`-inf`
`NaN`	`NaN`

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICO	FLOAT64
USCITA	FLOAT64	NUMERICO	BIGNUMERICA	FLOAT64

soffitto

CEILING(X)

Descrizione

Sinonimi di CEIL(X)

PIANO

FLOOR(X)

Descrizione

Restituisce il valore integrale più grande che non è maggiore di X.

X	PIANO(X)
2.0	2.0
2,3	2.0
2,8	2.0
2,5	2.0
-2,3	-3,0
-2,8	-3,0
-2,5	-3,0
0	0
`+inf`	`+inf`
`-inf`	`-inf`
`NaN`	`NaN`

Tipo di dati da restituire

INGRESSO	INT64	NUMERICO	BIGNUMERICA	FLOAT64
USCITA	FLOAT64	NUMERICO	BIGNUMERICA	FLOAT64

COS

COS(X)

Descrizione

Calcola il coseno di X, dove X è specificato in radianti. Mai.

X	COS(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`

PUOI

COSH(X)

Descrizione

Calcola il coseno iperbolico di X, dove è specificato X in radianti. Genera un errore se si verifica l'overflow.

X	COSH(X)
`+inf`	`+inf`
`-inf`	`+inf`
`NaN`	`NaN`

Campagne per app per incrementare il coinvolgimento

ACOS(X)

Descrizione

Calcola il valore principale del coseno inverso di X. Il valore restituito è compreso nell'intervallo [0,π]. Genera un errore se X è un valore al di fuori dell'intervallo [-1, 1].

X	ACOS(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`
X < -1	Errore
X > 1	Errore

ACOSH

ACOSH(X)

Descrizione

Calcola il coseno iperbolico inverso di X. Genera un errore se X è un valore inferiore a 1.

X	ACOSH(X)
`+inf`	`+inf`
`-inf`	`NaN`
`NaN`	`NaN`
X < 1	Errore

SIN

SIN(X)

Descrizione

Calcola il seno di X, dove X è specificato in radianti. Mai.

X	SIN(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`

SENH

SINH(X)

Descrizione

Calcola il seno iperbolico di X, dove X è specificato in radianti. Genera un errore se si verifica l'overflow.

X	SINH(X)
`+inf`	`+inf`
`-inf`	`-inf`
`NaN`	`NaN`

ASIN

ASIN(X)

Descrizione

Calcola il valore principale del seno inverso di X. Il valore restituito è compreso nell'intervallo [-π/2,π/2]. Genera un errore se X non rientra nell'intervallo [-1, 1].

X	ASIN(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`
X < -1	Errore
X > 1	Errore

ASINH

ASINH(X)

Descrizione

Calcola il seno iperbolico inverso di X. Errore.

X	ASINH(X)
`+inf`	`+inf`
`-inf`	`-inf`
`NaN`	`NaN`

TAN

TAN(X)

Descrizione

Calcola la tangente di X, dove X è specificato in radianti. Genera un errore se si verifica l'overflow.

X	TAN(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`

NH

TANH(X)

Descrizione

Calcola la tangente iperbolica di X, dove X è specificato in radianti. senza errori.

X	TANH(X)
`+inf`	1.0
`-inf`	-1,0
`NaN`	`NaN`

ATAN

ATAN(X)

Descrizione

Calcola il valore principale della tangente inversa di X. Il valore restituito è compreso nell'intervallo [-π/2,π/2]. Errore.

X	ATAN(X)
`+inf`	π/2
`-inf`	-π/2
`NaN`	`NaN`

ATANH

ATANH(X)

Descrizione

Calcola la tangente iperbolica inversa di X. Genera un errore se X non rientra nell'intervallo [-1, 1].

X	ATANH(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`
X < -1	Errore
X > 1	Errore

ATAN2

ATAN2(X, Y)

Descrizione

Calcola il valore principale della tangente inversa di X/Y utilizzando i segni dei due argomenti per determinare il quadrante. Il valore restituito è compreso nell'intervallo [-π,π].

X	A	ATAN2(X, Y)
`NaN`	Qualsiasi valore	`NaN`
Qualsiasi valore	`NaN`	`NaN`
0.0	0.0	0.0
Valore finlandese positivo	`-inf`	π.
Valore negativo negativo	`-inf`	-π
Valore finlandese	`+inf`	0.0
`+inf`	Valore finlandese	π/2
`-inf`	Valore finlandese	-π/2
`+inf`	`-inf`	3⁄4 π
`-inf`	`-inf`	-3⁄4 π
`+inf`	`+inf`	π/4
`-inf`	`+inf`	-π/4

INTERVALLO_BUCKET

RANGE_BUCKET(point, boundaries_array)

Descrizione

RANGE_BUCKET esegue la scansione di un array ordinato e restituisce la posizione in base 0 del limite superiore del punto. Questo può essere utile se devi raggruppare i dati per creare partizioni, istogrammi, regole definite dall'attività e altro ancora.

RANGE_BUCKET segue queste regole:

Se il punto è presente nell'array, restituisce l'indice del successivo valore maggiore.

RANGE_BUCKET(20, [0, 10, 20, 30, 40]) -- 3 is return value
RANGE_BUCKET(20, [0, 10, 20, 20, 40, 40]) -- 4 is return value

Se il punto non esiste nell'array, ma è compreso tra due valori, restituisce l'indice del valore più grande.
```
RANGE_BUCKET(25, [0, 10, 20, 30, 40]) -- 3 is return value
```
Se il punto è più piccolo del primo valore nell'array, restituisce 0.
```
RANGE_BUCKET(-10, [5, 10, 20, 30, 40]) -- 0 is return value
```
Se il punto è maggiore o uguale all'ultimo valore dell'array, restituisce la lunghezza dell'array.
```
RANGE_BUCKET(80, [0, 10, 20, 30, 40]) -- 5 is return value
```

Se l'array è vuoto, restituisce 0.

RANGE_BUCKET(80, []) -- 0 is return value

Se il punto è NULL o NaN, restituisce NULL.

RANGE_BUCKET(NULL, [0, 10, 20, 30, 40]) -- NULL is return value

Il tipo di dati per il punto e l'array deve essere compatibile.

RANGE_BUCKET('a', ['a', 'b', 'c', 'd']) -- 1 is return value
RANGE_BUCKET(1.2, [1, 1.2, 1.4, 1.6]) -- 2 is return value
RANGE_BUCKET(1.2, [1, 2, 4, 6]) -- execution failure

L'errore di esecuzione si verifica quando:

L'array ha un valore NaN o NULL.

RANGE_BUCKET(80, [NULL, 10, 20, 30, 40]) -- execution failure

L'array non è ordinato in ordine crescente.

RANGE_BUCKET(30, [10, 30, 20, 40, 50]) -- execution failure

Parametri

point: un valore generico.
boundaries_array: un array generico di valori.

Valore restituito

INT64

Esempi

In una tabella denominata students, controlla quanti record esisterebbero in ogni bucket age_group, in base all'età di uno studente:

age_group 0 (età &10)
age_group 1 (età >= 10, age < 20)
age_group 2 (età >= 20, age < 30)
age_group 3 (età >= 30)

WITH students AS
(
  SELECT 9 AS age UNION ALL
  SELECT 20 AS age UNION ALL
  SELECT 25 AS age UNION ALL
  SELECT 31 AS age UNION ALL
  SELECT 32 AS age UNION ALL
  SELECT 33 AS age
)
SELECT RANGE_BUCKET(age, [10, 20, 30]) AS age_group, COUNT(*) AS count
FROM students
GROUP BY 1

+--------------+-------+
| age_group    | count |
+--------------+-------+
| 0            | 1     |
| 2            | 2     |
| 3            | 3     |
+--------------+-------+

Funzioni di navigazione

Le seguenti sezioni descrivono le funzioni di navigazione supportate da BigQuery. Le funzioni di navigazione sono funzioni secondarie di una finestra. Per creare una chiamata a funzione finestra e saperne di più sulla sintassi per le funzioni finestra, consulta Chiamate funzione finestra.

Le funzioni di navigazione solitamente calcolano alcuni value_expression su una riga diversa nel frame della finestra rispetto alla riga corrente. La sintassi della clausola OVER varia a seconda delle funzioni di navigazione.

Per tutte le funzioni di navigazione, il tipo di dati dei risultati è dello stesso tipo di value_expression.

VALORE_PRINCIPALE

FIRST_VALUE (value_expression [{RESPECT | IGNORE} NULLS])
OVER over_clause

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  ORDER BY expression [ { ASC | DESC }  ] [, ...]
  [ window_frame_clause ]

Descrizione

Restituisce il valore di value_expression per la prima riga nel frame della finestra corrente.

Questa funzione include i valori NULL nel calcolo, a meno che non sia presente IGNORE NULLS. Se IGNORE NULLS è presente, la funzione esclude NULL i valori dal calcolo.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione Chiamate con funzione Finestra.

Tipi di argomenti supportati

value_expression può essere di qualsiasi tipo di dati che può restituire un'espressione.

Tipo di dati da restituire

Stesso tipo di value_expression.

Esempi

L'esempio seguente calcola il tempo più rapido per ciascuna divisione.

WITH finishers AS
 (SELECT 'Sophia Liu' as name,
  TIMESTAMP '2016-10-18 2:51:45' as finish_time,
  'F30-34' as division
  UNION ALL SELECT 'Lisa Stelzner', TIMESTAMP '2016-10-18 2:54:11', 'F35-39'
  UNION ALL SELECT 'Nikki Leith', TIMESTAMP '2016-10-18 2:59:01', 'F30-34'
  UNION ALL SELECT 'Lauren Matthews', TIMESTAMP '2016-10-18 3:01:17', 'F35-39'
  UNION ALL SELECT 'Desiree Berry', TIMESTAMP '2016-10-18 3:05:42', 'F35-39'
  UNION ALL SELECT 'Suzy Slane', TIMESTAMP '2016-10-18 3:06:24', 'F35-39'
  UNION ALL SELECT 'Jen Edwards', TIMESTAMP '2016-10-18 3:06:36', 'F30-34'
  UNION ALL SELECT 'Meghan Lederer', TIMESTAMP '2016-10-18 3:07:41', 'F30-34'
  UNION ALL SELECT 'Carly Forte', TIMESTAMP '2016-10-18 3:08:58', 'F25-29'
  UNION ALL SELECT 'Lauren Reasoner', TIMESTAMP '2016-10-18 3:10:14', 'F30-34')
SELECT name,
  FORMAT_TIMESTAMP('%X', finish_time) AS finish_time,
  division,
  FORMAT_TIMESTAMP('%X', fastest_time) AS fastest_time,
  TIMESTAMP_DIFF(finish_time, fastest_time, SECOND) AS delta_in_seconds
FROM (
  SELECT name,
  finish_time,
  division,
  FIRST_VALUE(finish_time)
    OVER (PARTITION BY division ORDER BY finish_time ASC
    ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS fastest_time
  FROM finishers);

+-----------------+-------------+----------+--------------+------------------+
| name            | finish_time | division | fastest_time | delta_in_seconds |
+-----------------+-------------+----------+--------------+------------------+
| Carly Forte     | 03:08:58    | F25-29   | 03:08:58     | 0                |
| Sophia Liu      | 02:51:45    | F30-34   | 02:51:45     | 0                |
| Nikki Leith     | 02:59:01    | F30-34   | 02:51:45     | 436              |
| Jen Edwards     | 03:06:36    | F30-34   | 02:51:45     | 891              |
| Meghan Lederer  | 03:07:41    | F30-34   | 02:51:45     | 956              |
| Lauren Reasoner | 03:10:14    | F30-34   | 02:51:45     | 1109             |
| Lisa Stelzner   | 02:54:11    | F35-39   | 02:54:11     | 0                |
| Lauren Matthews | 03:01:17    | F35-39   | 02:54:11     | 426              |
| Desiree Berry   | 03:05:42    | F35-39   | 02:54:11     | 691              |
| Suzy Slane      | 03:06:24    | F35-39   | 02:54:11     | 733              |
+-----------------+-------------+----------+--------------+------------------+

LAST_VALUE

LAST_VALUE (value_expression [{RESPECT | IGNORE} NULLS])
OVER over_clause

over_clause:
  { named_window | ( [ window_specification ] ) }

window_specification:
  [ named_window ]
  [ PARTITION BY partition_expression [, ...] ]
  ORDER BY expression [ { ASC | DESC }  ] [, ...]
  [ window_frame_clause ]

Descrizione

Restituisce il valore di value_expression per l'ultima riga nel frame della finestra corrente.

Questa funzione include i valori NULL nel calcolo, a meno che non sia presente IGNORE NULLS. Se IGNORE NULLS è presente, la funzione esclude NULL i valori dal calcolo.

Per saperne di più sulla clausola OVER e su come utilizzarla, consulta la sezione