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
eNaN
possono essere restituiti solo se uno degli operandi è+/-inf
oNaN
. 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 difieldname
. 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 unNULL
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. RestituisceNULL
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. RestituisceNULL
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'espressioneJSON
che contiene un elemento o un campo array da restituire.[array_element_id]
: un'espressioneINT64
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 valoreNULL
di SQL.[field_name]
: un'espressioneSTRING
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 unNULL
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 inputNULL
restituisceNULL
.
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:
|
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)
Quando utilizzi l'operatore IN
, viene applicata la seguente semantica nel seguente ordine:
- Restituisce
FALSE
sevalue_set
è vuoto. - Restituisce
NULL
sesearch_value
èNULL
. - Restituisce
TRUE
sevalue_set
contiene un valore uguale asearch_value
. - Restituisce
NULL
sevalue_set
contiene unNULL
. - Restituisce
FALSE
.
Quando utilizzi l'operatore NOT IN
, viene applicata la seguente semantica nel seguente ordine:
- Restituisce
TRUE
sevalue_set
è vuoto. - Restituisce
NULL
sesearch_value
èNULL
. - Restituisce
FALSE
sevalue_set
contiene un valore uguale asearch_value
. - Restituisce
NULL
sevalue_set
contiene unNULL
. - 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
restituisce2
.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 valoriNULL
vengono considerati diversi dai valoriNULL
, non da altri valoriNULL
. - I valori
NaN
sono considerati distinti dai valori nonNaN
, ma non altri valoriNaN
.
Tipi di input
expression_1
: il primo valore da confrontare. Può essere un tipo di dati raggruppabile,NULL
oNaN
.expression_2
: il secondo valore da confrontare. Può essere un tipo di dati raggruppabile,NULL
oNaN
.NOT
: se presente, il valore dell'outputBOOL
è 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
1.
COUNT(*)
[OVER over_clause]
2.
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 daNULL
.
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
.
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 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
.
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
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
.
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 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
.
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 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
.
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 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
.
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 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 sketch
HLL++ e li unisce in un nuovo schizzo.
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. 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
.
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
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
.
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
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
.
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:
|
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
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
.
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
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
.
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
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 |
---|---|---|
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
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 |
---|---|---|
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
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 |
---|---|---|
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
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 |
---|---|---|
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
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 |
---|---|---|
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
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 |
---|---|---|
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
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 |
---|---|---|
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
oHH
, 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 comeDATE
.
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.
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 |
---|---|---|
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
.
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 |
---|---|---|
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
.
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 |
---|---|---|
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
.
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 |
---|---|---|
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
.
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 |
---|---|---|
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
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 |
---|---|---|
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
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 |
---|---|---|
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:
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 |
---|---|---|
0 | 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'
|
9 | 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
oNaN
, restituisceNULL
.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
oNULL
.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