Guida alla traduzione SQL di Snowflake

Questo documento illustra le analogie e le differenze nella sintassi SQL tra Snowflake e BigQuery per aiutarti ad accelerare la pianificazione e l'esecuzione della migrazione del tuo EDW (Enterprise Data Warehouse) a BigQuery. Dati Snowflake Il warehousing è progettato in modo da funzionare con la sintassi SQL specifica di Snowflake. Script scritto per Snowflake potrebbe essere necessario apportare modifiche prima di poter essere utilizzati in in BigQuery, perché i dialetti SQL variano tra i servizi. Utilizza le funzionalità di traduzione SQL batch in eseguire la migrazione collettiva degli script SQL traduzione SQL interattiva per tradurre query ad hoc. L'SQL Snowflake è supportato in anteprima.

Nota: in alcuni casi non esiste una mappatura diretta tra un elemento SQL in Snowflake e BigQuery. Tuttavia, nella maggior parte dei casi, puoi ottenere la stessa funzionalità in BigQuery che in Snowflake utilizzando un metodo alternativo, come mostrato negli esempi di questo documento.

Tipi di dati

Questa sezione mostra gli equivalenti tra i tipi di dati in Snowflake e in in BigQuery.

Snowflake	BigQuery	Note
NUMBER/ DECIMAL/NUMERIC	NUMERIC	Il tipo di dati NUMBER in Snowflake supporta 38 cifre di precisione e 37 cifre di scala. La precisione e la scala possono essere specificate in base all'utente. BigQuery supporta NUMERIC e BIGNUMERIC con precisione e scalabilità specificate facoltativamente entro determinati limiti.
INT/INTEGER	BIGNUMERIC	INT/INTEGER e tutti gli altri tipi di dati simili a INT, ad esempio BIGINT, TINYINT, SMALLINT, BYTEINT rappresentano un alias per il tipo di dati NUMBER in cui la precisione e la scala non possono essere specificate ed è sempre NUMBER(38, 0)
BIGINT	BIGNUMERIC
SMALLINT	BIGNUMERIC
TINYINT	BIGNUMERIC
BYTEINT	BIGNUMERIC
FLOAT/ FLOAT4/ FLOAT8	FLOAT64	Il tipo di dati FLOAT in Snowflake stabilisce "NaN" come > X, dove X è qualsiasi valore FLOAT (diverso da "NaN"). Il tipo di dati FLOAT in BigQuery stabilisce "NaN" come < X, dove X è qualsiasi valore FLOAT (diverso da "NaN" stesso).
DOUBLE/ DOUBLE PRECISION/ REAL	FLOAT64	Il tipo di dati DOUBLE in Snowflake è sinonimo del tipo di dati FLOAT in Snowflake, ma viene comunemente visualizzato erroneamente come FLOAT. È archiviato correttamente come DOUBLE.
VARCHAR	STRING	Il tipo di dati VARCHAR in Snowflake ha una lunghezza massima di 16 MB (non compressi). Se la lunghezza non è specificata, il valore predefinito è la lunghezza massima. Il tipo di dati STRING in BigQuery viene memorizzato come Unicode con codifica UTF-8 di lunghezza variabile. La lunghezza massima è di 16.000 caratteri.
CHAR/CHARACTER	STRING	Il tipo di dati CHAR in Snowflake ha una lunghezza massima di 1.
STRING/TEXT	STRING	Il tipo di dati STRING in Snowflake è sinonimo del VARCHAR di Snowflake.
BINARY	BYTES
VARBINARY	BYTES
BOOLEAN	BOOL	Il tipo di dati BOOL in BigQuery può accettare solo TRUE/FALSE, a differenza del tipo di dati BOOL in Snowflake, che può accettare TRUE/FALSE/NULL.
DATE	DATE	Il tipo DATE in Snowflake accetta la maggior parte dei formati di data comuni, a differenza del tipo DATE in BigQuery, che accetta solo le date nel formato "AAAA-[M]M-[D]D".
TIME	TIME	Il tipo TIME in Snowflake supporta una precisione da 0 a 9 nanosecondi, mentre il tipo TIME in BigQuery supporta una precisione da 0 a 6 nanosecondi.
TIMESTAMP	DATETIME	TIMESTAMP è un alias configurabile dall'utente che per impostazione predefinita è TIMESTAMP_NTZ, mappato a DATETIME in BigQuery.
TIMESTAMP_LTZ	TIMESTAMP
TIMESTAMP_NTZ/DATETIME	DATETIME
TIMESTAMP_TZ	TIMESTAMP
OBJECT	JSON	Il tipo OBJECT in Snowflake non supporta i valori con tipo esplicito. I valori sono del tipo VARIANT.
VARIANT	JSON	Il tipo OBJECT in Snowflake non supporta i valori con tipo esplicito. I valori sono di tipo VARIANT.
ARRAY	ARRAY<JSON>	Il tipo ARRAY in Snowflake può supportare solo i tipi VARIANT, mentre il tipo ARRAY in BigQuery può supportare tutti i tipi di dati, ad eccezione di un array stesso.

BigQuery include anche i seguenti tipi di dati che non hanno un indirizzo Analogico del fiocco di neve:

• DATETIME
• GEOGRAPHY

Sintassi delle query e operatori di query

Questa sezione illustra le differenze nella sintassi delle query tra Snowflake e BigQuery.

Istruzione SELECT

La maggior parte delle istruzione SELECT di Snowflake è compatibile con BigQuery. La tabella seguente contiene un elenco differenze minime.

Snowflake		BigQuery
SELECT TOP ... FROM table		SELECT expression FROM table ORDER BY expression DESC LIMIT number
SELECT x/total AS probability, ROUND(100 * probability, 1) AS pct FROM raw_data Nota: Snowflake supporta la creazione e il riferimento a un alias nella stessa istruzione SELECT.		SELECT x/total AS probability, ROUND(100 * (x/total), 1) AS pct FROM raw_data
SELECT * FROM ( VALUES (1), (2), (3) )		SELECT AS VALUE STRUCT(1, 2, 3)

Per impostazione predefinita, gli alias e gli identificatori Snowflake non fanno distinzione tra maiuscole e minuscole. Per mantenere la maiuscola, racchiudi gli alias e gli identificatori tra virgolette doppie (").

BigQuery supporta le seguenti espressioni in SELECT che non hanno un equivalente Snowflake:

• EXCEPT
• REPLACE

Clausola FROM

Una clausola FROM in una query specifica le possibili tabelle, visualizzazioni, sottoquery o funzioni di tabella da utilizzare in un'istruzione SELECT. Tutti questi riferimenti tabella sono supportati in in BigQuery.

La tabella seguente contiene un elenco di differenze minori.

Snowflake		BigQuery
SELECT $1, $2 FROM (VALUES (1, 'one'), (2, 'two'));		WITH table1 AS ( SELECT STRUCT(1 as number, 'one' as spelling) UNION ALL SELECT STRUCT(2 as number, 'two' as spelling) ) SELECT * FROM table1
SELECT* FROM table SAMPLE(10)		SELECT* FROM table TABLESAMPLE BERNOULLI (0.1 PERCENT)
SELECT * FROM table1 AT(TIMESTAMP => timestamp) SELECT * FROM table1 BEFORE(STATEMENT => statementID)		SELECT * FROM table FOR SYSTEM_TIME AS OF timestamp Nota: BigQuery non dispone di un'alternativa diretta alla funzione PRIMA di Snowflake per l'utilizzo di un ID istruzione. Il valore di timestamp non può essere precedente di più di 7 giorni rispetto al timestamp corrente.
@[namespace]<stage_name>[/path]		BigQuery non supporta il concetto di file temporanei.
SELECT* FROM table START WITH predicate CONNECT BY [PRIOR] col1 = [PRIOR] col2 [, ...] ...		BigQuery non offre un'alternativa diretta a CONNECT BY di Snowflake.

È possibile fare riferimento alle tabelle BigQuery nella clausola FROM utilizzando:

• [project_id].[dataset_id].[table_name]
• [dataset_id].[table_name]
• [table_name]

BigQuery supporta anche ulteriori riferimenti a tabelle:

• Versioni storiche della definizione della tabella e delle righe utilizzando FOR SYSTEM_TIME AS OF
• Percorsi campi o qualsiasi percorso che si risolve in un campo all'interno di un tipo di dati (ossia è un STRUCT)
• Array appiattiti

Clausola WHERE

La clausola WHERE di Snowflake e la clausola WHERE di BigQuery sono identiche, tranne per quanto segue:

Snowflake		BigQuery
SELECT col1, col2 FROM table1, table2 WHERE col1 = col2(+)		SELECT col1, col2 FROM table1 INNER JOIN table2 ON col1 = col2 Nota: BigQuery non supporta la sintassi (+) per i valori JOIN

Tipi di JOIN

Snowflake e BigQuery supportano i seguenti tipi di join:

• [INNER] JOIN
• LEFT [OUTER] JOIN
• RIGHT [OUTER] JOIN
• FULL [OUTER] JOIN
• CROSS JOINe l'equivalente "join con virgola" implicito

Sia Snowflake che BigQuery supportano la clausola ONandUSING.

La seguente tabella contiene un elenco di differenze di minore entità.

Snowflake		BigQuery
SELECT col1 FROM table1 NATURAL JOIN table2		SELECT col1 FROM table1 INNER JOIN table2 USING (col1, col2 [, ...]) Nota: in BigQuery, le clausole JOIN richiedono una condizione JOIN, a meno che non si tratti di un JOIN CROSS o una delle tabelle unite non sia un campo all'interno di un tipo di dati o di un array.
SELECT ... FROM table1 AS t1, LATERAL ( SELECT* FROM table2 AS t2 WHERE t1.col = t2.col ) Nota: a differenza dell'output di un join non laterale, l'output di un join laterale include solo le righe generate dalla visualizzazione in linea. Le righe sul lato sinistro non devono essere unite al lato destro perché le righe a sinistra sono già state prese in considerazione poiché sono state passate nella visualizzazione in linea.		SELECT ... FROM table1 as t1 LEFT JOIN table2 as t2 ON t1.col = t2.col Nota: BigQuery non supporta un'alternativa diretta per i valori LATERAL JOIN.

Clausola WITH

Un WITH di BigQuery clausola contiene una o più sottoquery con nome che vengono eseguite ogni volta che L'istruzione SELECT li fa riferimento. Fiocco di neve WITH si comportano allo stesso modo di BigQuery con l'eccezione che BigQuery non supporta WITH RECURSIVE.

Clausola GROUP BY

Le clausole GROUP BY di Snowflake supportano GROUP BY, GROUP BY ROLLUP, GROUP BY GROUPING SETS e GROUP BY CUBE, mentre le clausole GROUP BY di BigQuery supportano GROUP BY e GROUP BY ROLLUP.

Fiocco di neve HAVING e BigQuery HAVING sono sinonimo. Tieni presente che HAVING si verifica dopo GROUP BY e l'aggregazione e prima di ORDER BY.

Snowflake		BigQuery
SELECT col1 as one, col2 as two FROM table GROUP BY (one, 2)		SELECT col1 as one, col2 as two FROM table GROUP BY (one, 2)
SELECT col1 as one, col2 as two FROM table GROUP BY ROLLUP (one, 2)		SELECT col1 as one, col2 as two FROM table GROUP BY ROLLUP (one, 2)
SELECT col1 as one, col2 as two FROM table GROUP BY GROUPING SETS (one, 2) Nota: Snowflake consente fino a 128 set di raggruppamento nello stesso blocco di query		BigQuery non supporta un'alternativa diretta a GROUP BY GROUPING SETS di Snowflake.
SELECT col1 as one, col2 as two FROM table GROUP BY CUBE (one,2) Nota: Snowflake consente fino a 7 elementi (128 insiemi di raggruppamento) in ogni cubo		BigQuery non supporta un'alternativa diretta a GROUP BY CUBE di Snowflake.

Clausola ORDER BY

Esistono alcune differenze minori tra le clausole ORDER BY di Snowflake e le clausole ORDER BY di BigQuery.

Snowflake		BigQuery
In Snowflake, per impostazione predefinita, i NULL sono classificati come ultimi (in ordine crescente).		In BigQuery, i valori NULLS sono classificati per primi per impostazione predefinita (ordine crescente).
Puoi specificare se i valori NULL devono essere ordinati per primi o per ultimi utilizzando rispettivamente NULLS FIRST o NULLS LAST.		Non esiste un equivalente per specificare se i valori NULL devono essere i primi o gli ultimi in BigQuery.

Clausola LIMIT/FETCH

La clausola LIMIT/FETCH in Snowflake limita il numero massimo di righe restituite da un statement o da una sottoquery. LIMIT (sintassi Postgres) e FETCH (sintassi ANSI) producono lo stesso risultato.

In Snowflake e BigQuery, l'applicazione di una clausola LIMIT a una query non influisce sulla quantità di dati letti.

Snowflake		BigQuery
SELECT col1, col2 FROM table ORDER BY col1 LIMIT count OFFSET start SELECT ... FROM ... ORDER BY ... OFFSET start {[ROW | ROWS]} FETCH {[FIRST | NEXT]} count {[ROW | ROWS]} [ONLY] Nota: i valori NULL, stringa vuota ("") e $$$$ sono accettati e considerati "illimitati". L'uso principale è per connettori e driver.		SELECT col1, col2 FROM table ORDER BY col1 LIMIT count OFFSET start Nota: BigQuery non supporta FETCH. LIMIT sostituisce FETCH. Nota: in BigQuery, OFFSET deve essere utilizzato insieme a un LIMIT count. Assicurati di impostare il valore count INT64 sul numero minimo di righe ordinate necessarie per il massimo rendimento. Ordinare inutilmente tutte le righe dei risultati peggiorerà le prestazioni di esecuzione delle query.

Clausola QUALIFY

La QUALIFY in Snowflake ti consente di filtrare i risultati in base a funzioni finestra simili cosa fa HAVING con le funzioni aggregate e le clausole GROUP BY.

Snowflake		BigQuery
SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1;		La clausola QUALIFY Snowflake con una funzione di analisi come ROW_NUMBER(), COUNT() e con OVER PARTITION BY è espressa in BigQuery come clausola WHERE su una sottoquery che contiene il valore di analisi. ROW_NUMBER() in uso: SELECT col1, col2 FROM ( SELECT col1, col2 ROW NUMBER() OVER (PARTITION BY col1 ORDER by col2) RN FROM table ) WHERE RN = 1; Utilizzando ARRAY_AGG(), che supporta partizioni più grandi: SELECT result.* FROM ( SELECT ARRAY_AGG(table ORDER BY table.col2 DESC LIMIT 1) [OFFSET(0)] FROM table GROUP BY col1 ) AS result;

Funzioni

Le sezioni seguenti elencano le funzioni Snowflake e i relativi equivalenti BigQuery.

Funzioni di aggregazione

La tabella seguente mostra le mappature tra i dati aggregati di Snowflake e aggregati analitiche e approssimative di funzioni di aggregazione con BigQuery equivalenti.

Snowflake	BigQuery
ANY_VALUE([DISTINCT] expression) [OVER ...] Nota: DISTINCT non ha alcun effetto	ANY_VALUE(expression) [OVER ...]
APPROX_COUNT_DISTINCT([DISTINCT] expression) [OVER ...] Nota: DISTINCT non ha alcun effetto	APPROX_COUNT_DISTINCT(expression) Nota: BigQuery non supporta APPROX_COUNT_DISTINCT con le funzioni Window
APPROX_PERCENTILE(expression, percentile) [OVER ...] Nota: Snowflake non ha la possibilità di RESPECT NULLS	APPROX_QUANTILES([DISTINCT] expression,100) [OFFSET((CAST(TRUNC(percentile * 100) as INT64))] Nota: BigQuery non supporta APPROX_QUANTILES con le funzioni finestra
APPROX_PERCENTILE_ACCUMULATE (expression)	BigQuery non supporta la possibilità di memorizzare lo stato intermedio durante la previsione di valori approssimativi.
APPROX_PERCENTILE_COMBINE(state)	BigQuery non supporta la possibilità di archiviare lo stato intermedio per prevedere valori approssimativi.
APPROX_PERCENTILE_ESTIMATE(state, percentile)	BigQuery non supporta la possibilità di archiviare lo stato intermedio per prevedere valori approssimativi.
APPROX_TOP_K(expression, [number [counters]] Nota: se non viene specificato alcun parametro numerico, il valore predefinito è 1. I contatori devono essere molto più grandi del numero.	APPROX_TOP_COUNT(expression, number) Nota: BigQuery non supporta APPROX_TOP_COUNT con le funzioni finestra.
APPROX_TOP_K_ACCUMULATE(expression, counters)	BigQuery non supporta la possibilità di archiviare lo stato intermedio per prevedere valori approssimativi.
APPROX_TOP_K_COMBINE(state, [counters])	BigQuery non supporta la possibilità di archiviare lo stato intermedio per prevedere valori approssimativi.
APPROX_TOP_K_ESTIMATE(state, [k])	BigQuery non supporta la possibilità di memorizzare lo stato intermedio durante la previsione di valori approssimativi.
APPROXIMATE_JACCARD_INDEX([DISTINCT] expression)	Puoi utilizzare una funzione hash personalizzata per implementare MINHASH con k funzioni hash distinte. Un altro approccio per ridurre la varianza in MINHASH è mantenere k dei valori minimi di una funzione hash. In questo caso, l'indice di Jaccard può essere approssimato come segue: WITH minhash_A AS ( SELECT DISTINCT FARM_FINGERPRINT(TO_JSON_STRING(t)) AS h FROM TA AS t ORDER BY h LIMIT k), minhash_B AS ( SELECT DISTINCT FARM_FINGERPRINT(TO_JSON_STRING(t)) AS h FROM TB AS t ORDER BY h LIMIT k) SELECT COUNT(*) / k AS APPROXIMATE_JACCARD_INDEX FROM minhash_A INNER JOIN minhash_B ON minhash_A.h = minhash_B.h
APPROXIMATE_SIMILARITY([DISTINCT] expression)	È un sinonimo di APPROXIMATE_JACCARD_INDEX e può essere implementato nello stesso modo.
ARRAY_AGG([DISTINCT] expression1) [WITHIN GROUP (ORDER BY ...)] [OVER ([PARTITION BY expression2])] Note: Snowflake does not support ability to IGNORE|RESPECT NULLS and to LIMIT directly in ARRAY_AGG.	ARRAY_AGG([DISTINCT] expression1 [{IGNORE|RESPECT}] NULLS] [ORDER BY ...] LIMIT ...]) [OVER (...)]
AVG([DISTINCT] expression) [OVER ...]	AVG([DISTINCT] expression) [OVER ...] Nota: lo strumento AVG di BigQuery non esegue la trasmissione automatica sui dispositivi STRING.
BITAND_AGG(expression) [OVER ...]	BIT_AND(expression) [OVER ...] Nota: BigQuery non esegue il casting implicito delle colonne di caratteri/testo al valore INTEGER più vicino.
BITOR_AGG(expression) [OVER ...]	BIT_OR(expression) [OVER ...] Nota: BigQuery non esegue il casting implicito delle colonne di caratteri/testo al valore INTEGER più vicino.
BITXOR_AGG([DISTINCT] expression) [OVER ...]	BIT_XOR([DISTINCT] expression) [OVER ...] Nota: BigQuery non trasmette implicitamente colonne di carattere/testo al INTEGER più vicino.
BOOLAND_AGG(expression) [OVER ...] Nota: Snowflake consente di trattare i valori numerici, decimali e con rappresentazione in virgola mobile come TRUE se non pari a zero.	LOGICAL_AND(expression) [OVER ...]
BOOLOR_AGG(expression) [OVER ...] Nota: Snowflake consente di trattare i valori numerici, decimali e con rappresentazione in virgola mobile come TRUE se non pari a zero.	LOGICAL_OR(expression) [OVER ...]
BOOLXOR_AGG(expression) [OVER ([PARTITION BY <partition_expr> ]) Nota: Snowflake consente di trattare i valori numerici, decimali e in virgola mobile come TRUE se non sono pari a zero.	Per l'espressione numerica: SELECT CASE COUNT(*) WHEN 1 THEN TRUE WHEN 0 THEN NULL ELSE FALSE END AS BOOLXOR_AGG FROM T WHERE expression != 0 Per utilizzare OVER puoi eseguire il seguente esempio (è fornito un esempio booleano): SELECT CASE COUNT(expression) OVER (PARTITION BY partition_expr) WHEN 0 THEN NULL ELSE CASE COUNT( CASE expression WHEN TRUE THEN 1 END) OVER (PARTITION BY partition_expr) WHEN 1 THEN TRUE ELSE FALSE END END AS BOOLXOR_AGG FROM T
CORR(dependent, independent) [OVER ...]	CORR(dependent, independent) [OVER ...]
COUNT([DISTINCT] expression [,expression2]) [OVER ...]	COUNT([DISTINCT] expression [,expression2]) [OVER ...]
COVAR_POP(dependent, independent) [OVER ...]	COVAR_POP(dependent, independent) [OVER ...]
COVAR_SAMP(dependent, independent) [OVER ...]	COVAR_SAMP(dependent, independent) [OVER ...]
GROUPING(expression1, [,expression2...])	BigQuery non supporta un'alternativa diretta a GROUPING di Snowflake. Disponibile tramite una funzione definita dall'utente.
GROUPING_ID(expression1, [,expression2...])	BigQuery non supporta un'alternativa diretta a GROUPING_ID di Snowflake. Disponibile tramite una funzione definita dall'utente.
HASH_AGG([DISTINCT] expression1, [,expression2]) [OVER ...]	SELEZIONA BIT_XOR( FARM_FINGERPRINT( TO_JSON_STRING(t))) [OVER] DA t
SELECT HLL([DISTINCT] expression1, [,expression2]) [OVER ...] Nota: Snowflake non consente di specificare la precisione.	SELECT HLL_COUNT.EXTRACT(sketch) FROM ( SELECT HLL_COUNT.INIT(expression) AS sketch FROM table ) Nota: BigQuery non supporta HLL_COUNT… con le funzioni Window. Un utente non può includere più espressioni in una singola funzione HLL_COUNT....
HLL_ACCUMULATE([DISTINCT] expression) Nota: Snowflake non ti consente di specificare la precisione.	HLL_COUNT.INIT(expression [, precision])
HLL_COMBINE([DISTINCT] state)	HLL_COUNT.MERGE_PARTIAL(schizzo)
HLL_ESTIMATE(state)	HLL_COUNT.EXTRACT(sketch)
HLL_EXPORT(binary)	BigQuery non supporta un'alternativa diretta a HLL_EXPORT di Snowflake.
HLL_IMPORT(object)	BigQuery non supporta un'alternativa diretta a HLL_IMPORT di Snowflake.
KURTOSIS(expression) [OVER ...]	BigQuery non supporta un'alternativa diretta a KURTOSIS di Snowflake.
LISTAGG( [DISTINCT] aggregate_expression [, delimiter] ) [OVER ...]	STRING_AGG( [DISTINCT] aggregate_expression [, delimiter] ) [OVER ...]
MEDIAN(expression) [OVER ...] Nota: Snowflake non supporta la possibilità di IGNORE|RESPECT NULLS e LIMIT direttamente in ARRAY_AGG.	PERCENTILE_CONT( value_expression, 0.5 [ {RESPECT | IGNORE} NULLS] ) OVER()
MAX(expression) [OVER ...] MIN(expression) [OVER ...]	MAX(expression) [OVER ...] MIN(expression) [OVER ...]
MINHASH(k, [DISTINCT] expressions)	Puoi utilizzare una UDF personalizzata per implementare MINHASH con k funzioni hash distinte. Un altro approccio per ridurre la varianza in MINHASH è mantenere k dei valori minimi di una funzione hash: SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS MINHASH FROM t ORDER BY MINHASH LIMIT k
MINHASH_COMBINE([DISTINCT] state)	<code<select FROM ( SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS h FROM TA AS t ORDER BY h LIMIT k UNION SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS h FROM TB AS t ORDER BY h LIMIT k ) ORDER BY h LIMIT k
MODE(expr1) OVER ( [ PARTITION BY <expr2> ] )	SELECT expr1 FROM ( SELECT expr1, ROW_NUMBER() OVER ( PARTITION BY expr2 ORDER BY cnt DESC) rn FROM ( SELECT expr1, expr2, COUNTIF(expr1 IS NOT NULL) OVER (PARTITION BY expr2, expr1) cnt FROM t)) WHERE rn = 1
OBJECT_AGG(key, value) [OVER ...]	Puoi prendere in considerazione l'utilizzo di TO_JSON_STRING per convertire un valore in una stringa in formato JSON.
PERCENTILE_CONT(percentile) WITHIN GROUP (ORDER BY value_expression) [OVER ...]	PERCENTILE_CONT( value_expression, percentile [ {RESPECT | IGNORE} NULLS] ) OVER()
PERCENTILE_DISC(percentile) WITHIN GROUP (ORDER BY value_expression) [OVER ...]	PERCENTILE_DISC( value_expression, percentile [ {RESPECT | IGNORE} NULLS] ) OVER()
REGR_AVGX(dependent, independent) [OVER ...]	SELECT AVG(independent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) )
REGR_AVGY(dependent, independent) [OVER ...]	SELECT AVG(dependent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) )
REGR_COUNT(dependent, independent) [OVER ...]	SELECT COUNT(*) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) )
REGR_INTERCEPT(dependent, independent) [OVER ...]	SELECT AVG(dependent) - COVAR_POP(dependent,independent)/ VAR_POP(dependent) * AVG(independent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_R2(dependent, independent) [OVER ...]	SELECT CASE WHEN VAR_POP(independent) = 0 THEN NULL WHEN VAR_POP(dependent) = 0 AND VAR_POP(independent) != 0 THEN 1 ELSE POWER(CORR(dependent, independent), 2) END AS ... FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_SLOPE(dependent, independent) [OVER ...]	SELECT COVAR_POP(dependent,independent)/ VAR_POP(dependent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_SXX(dependent, independent) [OVER ...]	SELECT COUNT(*)*VAR_POP(independent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_SYY(dependent, independent) [OVER ...]	SELECT COUNT(*)*VAR_POP(dependent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
SKEW(expression)	BigQuery non supporta un'alternativa diretta a quella di Snowflake SKEW.
STDDEV([DISTINCT] expression) [OVER ...]	STDDEV([DISTINCT] expression) [OVER ...]
STDDEV_POP([DISTINCT] expression) [OVER ...]	STDDEV_POP([DISTINCT] expression) [OVER ...]
STDDEV_SAMP([DISTINCT] expression) [OVER ...]	STDDEV_SAMP([DISTINCT] expression) [OVER ...]
SUM([DISTINCT] expression) [OVER ...]	SUM([DISTINCT] expression) [OVER ...]
VAR_POP([DISTINCT] expression) [OVER ...] Nota: Snowflake supporta la possibilità di eseguire il casting di VARCHAR in valori a virgola mobile.	VAR_POP([DISTINCT] expression) [OVER ...]
VARIANCE_POP([DISTINCT] expression) [OVER ...] Nota: Snowflake supporta la possibilità di eseguire il casting di VARCHAR in valori a virgola mobile.	VAR_POP([DISTINCT] expression) [OVER ...]
VAR_SAMP([DISTINCT] expression) [OVER ...] Nota: Snowflake supporta la possibilità di eseguire il casting di VARCHAR in valori a virgola mobile.	VAR_SAMP([DISTINCT] expression) [OVER ...]
VARIANCE([DISTINCT] expression) [OVER ...] Nota: Snowflake supporta la possibilità di trasmettere VARCHAR a valori in virgola mobile.	VARIANCE([DISTINCT] expression) [OVER ...]

BigQuery offre anche le seguenti funzioni di aggregazione, analisi aggregata e aggregazione approssimativa, che non hanno un analogo diretto in Snowflake:

• COUNTIF
• ARRAY_CONCAT_AGG
• HLL_COUNT.MERGE

Funzioni di espressioni a livello di bit

La tabella seguente mostra le mappature tra l'espressione a bit comune Snowflake con i rispettivi equivalenti BigQuery.

Se il tipo di dati di un'espressione non è INTEGER, Snowflake tenta di trasmettere a INTEGER. Tuttavia, BigQuery non tenta di eseguire il trasferimento a INTEGER.

Snowflake	BigQuery
BITAND(expression1, expression2)	BIT_ADD(x) FROM UNNEST([expression1, expression2]) AS x expression1 & expression2
BITNOT(expression)	~ expression
BITOR(expression1, expression2)	BIT_OR(x) FROM UNNEST([expression1, expression2]) AS x expression1 | expression2
BITSHIFTLEFT (expression, n)	expression << n
BITSHIFTRIGHT (expression, n)	expression >> n
BITXOR(expression, expression) Nota: Snowflake non supporta DISTINCT.	BIT_XOR([DISTINCT] x) FROM UNNEST([expression1, expression2]) AS x expression ^ expression

Funzioni di espressioni condizionali

La tabella seguente mostra le mappature tra il condizionale Snowflake comune con i rispettivi equivalenti BigQuery.

Snowflake	BigQuery
expression [ NOT ] BETWEEN lower AND upper	(expression >= lower AND expression <= upper)
BOOLAND(expression1, expression2) Nota: Snowflake consente di trattare i valori numerici, decimali e in virgola mobile come TRUE se non sono pari a zero.	LOGICAL_AND(x) FROM UNNEST([expression1, expression2]) AS x expression1 AND expression2
BOOLNOT(expression1) Nota: Snowflake consente di trattare i valori numerici, decimali e con rappresentazione in virgola mobile come TRUE se non pari a zero.	NOT expression
BOOLOR Nota: Snowflake consente di trattare i valori numerici, decimali e con rappresentazione in virgola mobile come TRUE se non pari a zero.	LOGICAL_OR(x) FROM UNNEST([expression1, expression2]) AS x expression1 OR expression2
BOOLXOR Nota: Snowflake consente di trattare i valori numerici, decimali e con rappresentazione in virgola mobile come TRUE se non pari a zero.	BigQuery non supporta un'alternativa diretta a BOOLXOR. di Snowflake
CASE [expression] WHEN condition1 THEN result1 [WHEN condition2 THEN result2] [...] [ELSE result3] END	CASE [expression] WHEN condition1 THEN result1 [WHEN condition2 THEN result2] [...] [ELSE result3] END
COALESCE(expr1, expr2, [,...]) Nota: Snowflake richiede almeno due espressioni. BigQuery ne richiede solo uno.	COALESCE(expr1, [,...])
DECODE(expression, search1, result1, [search2, result2...] [,default])	CASE [expression] WHEN condition1 THEN result1 [WHEN condition2 THEN result2] [...] [ELSE result3] END Nota: BigQuery supporta le sottoquery nelle istruzioni di condizione. Può essere utilizzato per riprodurre l'elemento DECODE di Snowflake. L'utente deve utilizzare IS NULL anziché = NULL per abbinare le espressioni di selezione NULL alle espressioni di ricerca NULL.
EQUAL_NULL(expression1, expression2)	BigQuery non supporta un'alternativa diretta a EQUAL_NULL. di Snowflake
GREATEST(expression1, [,expression2]...)	GREATEST(expression1, [,expression2]...)
IFF(condition, true_result, false_result)	IF(condition, true_result, false_result)
IFNULL(expression1, expression2)	IFNULL(expression1, expression2)
[ NOT ] IN ...	[ NOT ] IN ...
expression1 IS [ NOT ] DISTINCT FROM expression2	BigQuery non supporta un'alternativa diretta a IS [ NOT ] DISTINCT FROM. di Snowflake
expression IS [ NOT ] NULL	expression IS [ NOT ] NULL
IS_NULL_VALUE(variant_expr)	BigQuery non supporta i tipi di dati VARIANT.
LEAST(expression,...)	LEAST(expression,...)
NULLIF(expression1,expression2)	NULLIF(expression1,expression2)
NVL(expression1, expression2)	IFNULL(expression1,expression2)
NVL2(expr1,expr2,expr2)	IF(expr1 IS NOT NULL, expr2,expr3)
REGR_VALX(expr1,expr2)	IF(expr1 IS NULL, NULL, expr2) Nota: BigQuery non supporta un'alternativa diretta alle funzioni REGR... di Snowflake.
REGR_VALY(expr1,expr2)	IF(expr2 IS NULL, NULL, expr1) Nota: BigQuery non supporta un'alternativa diretta alle funzioni REGR... di Snowflake.
ZEROIFNULL(expression)	IFNULL(expression,0)

Funzioni di contesto

La tabella seguente mostra le mappature tra funzioni di contesto comuni a Snowflake con gli equivalenti BigQuery.

Snowflake	BigQuery
CURRENT_ACCOUNT()	SESSION_USER() Nota: non è un confronto diretto. Snowflake restituisce l'ID account, BigQuery restituisce l'indirizzo email dell'utente.
CURRENT_CLIENT()	Concetto non utilizzato in BigQuery
CURRENT_DATABASE()	SELECT catalog_name FROM INFORMATION_SCHEMA.SCHEMATA Viene restituita una tabella dei nomi dei progetti. Non è un confronto diretto.
CURRENT_DATE[()] Nota: Snowflake non applica "()" dopo il comando CURRENT_DATE per rispettare gli standard ANSI.	CURRENT_DATE([timezone]) Nota: CURRENT_DATE di BigQuery supporta la specifica facoltativa del fuso orario.
CURRENT_REGION()	SELECT location FROM INFORMATION_SCHEMA.SCHEMATA Nota: INFORMATION_SCHEMA.SCHEMATA di BigQuery restituisce riferimenti alla posizione più generali rispetto a CURRENT_REGION() di Snowflake. Non è un confronto diretto.
CURRENT_ROLE()	Concetto non utilizzato in BigQuery
CURRENT_SCHEMA()	SELECT schema_name FROM INFORMATION_SCHEMA.SCHEMATA Questa operazione restituisce una tabella di tutti i set di dati (chiamati anche schemi) disponibili nel progetto o nella regione. Non è un confronto diretto.
CURRENT_SCHEMAS()	Concetto non utilizzato in BigQuery
CURRENT_SESSION()	Concetto non utilizzato in BigQuery
CURRENT_STATEMENT()	SELECT query FROM INFORMATION_SCHEMA.JOBS_BY_* Nota: INFORMATION_SCHEMA.JOBS_BY_* di BigQuery consente di cercare query per tipo di job, tipo di inizio/fine e così via.
CURRENT_TIME[([frac_sec_prec])] Nota: Snowflake consente la precisione facoltativa dei secondi frazionari. I valori validi sono compresi tra 0 e 9 nanosecondi. Il valore predefinito è 9. Per rispettare lo standard ANSI, questa funzionalità può essere chiamata senza il tasto "()".	CURRENT_TIME()
CURRENT_TIMESTAMP[([frac_sec_prec])] Nota: Snowflake consente una precisione facoltativa in frazioni di secondo. I valori validi sono compresi tra 0 e 9 nanosecondi. Il valore predefinito è 9. Per rispettare lo standard ANSI, questa funzionalità può essere chiamata senza il tasto "()". Imposta TIMEZONE come parametro di sessione.	CURRENT_DATETIME([timezone]) CURRENT_TIMESTAMP() Nota: CURRENT_DATETIME restituisce il tipo di dati DATETIME (non supportato in Snowflake). CURRENT_TIMESTAMP restituisce il tipo di dati TIMESTAMP.
CURRENT_TRANSACTION()	SELECT job_id FROM INFORMATION_SCHEMA.JOBS_BY_* Nota: INFORMATION_SCHEMA.JOBS_BY_* di BigQuery consente di cercare gli ID job per tipo, tipo di inizio/fine e così via.
CURRENT_USER[()] Nota: Snowflake non applica "()" dopo il comando CURRENT_USER per rispettare gli standard ANSI.	SESSION_USER() SELECT user_email FROM INFORMATION_SCHEMA.JOBS_BY_* Nota: non è un confronto diretto. Snowflake restituisce il nome utente; BigQuery restituisce l'indirizzo email dell'utente.
CURRENT_VERSION()	Concetto non utilizzato in BigQuery
CURRENT_WAREHOUSE()	SELECT catalg_name FROM INFORMATION_SCHEMA.SCHEMATA
LAST_QUERY_ID([num])	SELECT job_id FROM INFORMATION_SCHEMA.JOBS_BY_* Nota: INFORMATION_SCHEMA.JOBS_BY_* di BigQuery consente di cercare gli ID job in base al tipo di job, al tipo di inizio/fine e così via.
LAST_TRANSACTION()	SELECT job_id FROM INFORMATION_SCHEMA.JOBS_BY_* Nota: INFORMATION_SCHEMA.JOBS_BY_* di BigQuery consente di cercare gli ID job per tipo, tipo di inizio/fine e così via.
LOCALTIME() Nota: Snowflake non applica "()" dopo il comando LOCALTIME per rispettare gli standard ANSI.	CURRENT_TIME()
LOCALTIMESTAMP()	CURRENT_DATETIME([timezone]) CURRENT_TIMESTAMP() Nota: CURRENT_DATETIME restituisce il tipo di dati DATETIME (non supportato in Snowflake). CURRENT_TIMESTAMP restituisce il tipo di dati TIMESTAMP.

Funzioni di conversione

La tabella seguente mostra le mappature tra le funzioni di conversione comuni di Snowflake con i relativi equivalenti di BigQuery.

Tieni presente che le funzioni che sembrano identiche in Snowflake BigQuery può restituire diversi tipi di dati.

Snowflake	BigQuery
CAST(expression AS type) expression :: type	CAST(expression AS type)
TO_ARRAY(expression)	[expression] ARRAY(subquery)
TO_BINARY(expression[, format]) Nota: Snowflake supporta le conversioni HEX, BASE64 e UTF-8. Snowflake supporta anche TO_BINARY utilizzando il tipo di dati VARIANT. BigQuery non ha un'alternativa al tipo di dati VARIANT.	TO_HEX(CAST(expression AS BYTES)) TO_BASE64(CAST(expression AS BYTES)) CAST(expression AS BYTES) Nota: la trasmissione predefinita di STRING di BigQuery utilizza la codifica UTF-8. Snowflake non ha un'opzione per supportare la codifica BASE32.
TO_BOOLEAN(expression) Nota: INT64 TRUE: in caso contrario, FALSE: 0 STRING TRUE: "true"/"t"/"yes"/"y"/"on"/"1", FALSE: "false"/"f"/"no"/"n"/"off"/"0"	CAST(expression AS BOOL) Nota: INT64 TRUE: altrimenti, FALSE: 0 STRING TRUE: "true", FALSE: "false"
TO_CHAR(expression[, format]) TO_VARCHAR(expression[, format]) Nota: i modelli di formato di Snowflake sono disponibili qui. BigQuery non ha un'alternativa al tipo di dati VARIANT.	CAST(expression AS STRING) Nota: l'espressione di input di BigQuery può essere formattata utilizzando FORMAT_DATE, FORMAT_DATETIME, FORMAT_TIME o FORMAT_TIMESTAMP.
TO_DATE(expression[, format]) DATE(expression[, format]) Nota: Snowflake supporta la possibilità di convertire direttamente i tipi INTEGER in tipi DATE. I modelli di formato di Snowflake sono disponibili qui. BigQuery non ha un'alternativa al tipo di dati VARIANT.	CAST(expression AS DATE) Nota: l'espressione di input di BigQuery può essere formattata utilizzando FORMAT, FORMAT_DATETIME o FORMAT_TIMESTAMP.
TO_DECIMAL(expression[, format] [,precision[, scale]] TO_NUMBER(expression[, format] [,precision[, scale]] TO_NUMERIC(expression[, format] [,precision[, scale]] Nota: i modelli di formato di Snowflake per i tipi di dati DECIMAL, NUMBER e NUMERIC sono disponibili qui. BigQuery non ha un'alternativa al tipo di dati VARIANT.	ROUND(CAST(expression AS NUMERIC) , x) Nota: l'espressione di input di BigQuery può essere formattata utilizzando FORMAT.
TO_DOUBLE(expression[, format]) Nota: i modelli di formato di Snowflake per i tipi di dati DOUBLE sono disponibili qui. BigQuery non ha un'alternativa al tipo di dati VARIANT.	CAST(expression AS FLOAT64) Nota: l'espressione di input di BigQuery può essere formattata utilizzando FORMAT.
TO_JSON(variant_expression)	BigQuery non ha un'alternativa al tipo di dati VARIANT di Snowflake.
TO_OBJECT(variant_expression)	BigQuery non ha un'alternativa al tipo di dati VARIANT di Snowflake.
TO_TIME(expression[, format]) TIME(expression[, format]) Nota: i modelli di formato di Snowflake per i STRING tipi di dati sono disponibili qui. BigQuery non ha un'alternativa al tipo di dati VARIANT.	CAST(expression AS TIME) Nota: BigQuery non dispone di un'alternativa al tipo di dati VARIANT di Snowflake. L'espressione di input di BigQuery può essere formattata utilizzando FORMAT, FORMAT_DATETIME, FORMAT_TIMESTAMP o FORMAT_TIME.
TO_TIMESTAMP(expression[, scale]) TO_TIMESTAMP_LTZ(expression[, scale]) TO_TIMESTAMP_NTZ(expression[, scale]) TO_TIMESTAMP_TZ(expression[, scale]) Nota: BigQuery non ha un'alternativa al tipo di dati VARIANT.	CAST(expression AS TIMESTAMP) Nota: l'espressione di input di BigQuery può essere formattata utilizzando FORMAT, FORMAT_DATE, FORMAT_DATETIME, FORMAT_TIME. Il fuso orario può essere incluso/non incluso tramite i parametri FORMAT_TIMESTAMP.
TO_VARIANT(expression)	BigQuery non ha un'alternativa al tipo di dati VARIANT di Snowflake.
TO_XML(variant_expression)	BigQuery non ha un'alternativa al tipo di dati VARIANT di Snowflake.
TRY_CAST(expression AS type)	SAFE_CAST(expression AS type)
TRY_TO_BINARY(expression[, format])	TO_HEX(SAFE_CAST(expression AS BYTES)) TO_BASE64(SAFE_CAST(expression AS BYTES)) SAFE_CAST(expression AS BYTES)
TRY_TO_BOOLEAN(expression)	SAFE_CAST(expression AS BOOL)
TRY_TO_DATE(expression)	SAFE_CAST(expression AS DATE)
TRY_TO_DECIMAL(expression[, format] [,precision[, scale]] TRY_TO_NUMBER(expression[, format] [,precision[, scale]] TRY_TO_NUMERIC(expression[, format] [,precision[, scale]]	ROUND( SAFE_CAST(expression AS NUMERIC) , x)
TRY_TO_DOUBLE(expression)	SAFE_CAST(expression AS FLOAT64)
TRY_TO_TIME(expression)	SAFE_CAST(expression AS TIME)
TRY_TO_TIMESTAMP(expression) TRY_TO_TIMESTAMP_LTZ(expression) TRY_TO_TIMESTAMP_NTZ(expression) TRY_TO_TIMESTAMP_TZ(expression)	SAFE_CAST(expression AS TIMESTAMP)

BigQuery offre anche le seguenti funzioni di conversione, che non hanno un analogo diretto in Snowflake:

• CODE_POINTS_TO_BYTES
• CODE_POINTS_TO_STRING
• FORMAT
• FROM_BASE32
• FROM_BASE64
• FROM_HEX
• SAFE_CONVERT_BYTES_TO_STRING
• TO_BASE32
• TO_CODE_POINTS

Funzioni di generazione dei dati

La tabella seguente mostra le mappature tra le funzioni comuni di generazione di dati di Snowflake e i relativi equivalenti di BigQuery.

Snowflake	BigQuery
NORMAL(mean, stddev, gen)	BigQuery non supporta un confronto diretto con NORMAL. di Snowflake
RANDOM([seed])	IF(RAND()>0.5, CAST(RAND()*POW(10, 18) AS INT64), (-1)*CAST(RAND()*POW(10, 18) AS INT64)) Nota: BigQuery non supporta il seeding
RANDSTR(length, gen)	BigQuery non supporta un confronto diretto con RANDSTR. di Snowflake
SEQ1 / SEQ2 / SEQ4 / SEQ8	BigQuery non supporta un confronto diretto con SEQ_. di Snowflake
UNIFORM(min, max, gen)	CAST(min + RAND()*(max-min) AS INT64) Nota:utilizza funzioni definite dall'utente permanenti per creare un equivalente al UNIFORM di Snowflake. Esempio qui.
UUID_STRING([uuid, name]) Nota: Snowflake restituisce 128 bit casuali. Snowflake supporta sia gli UUID versione 4 (casuali) che quelli versione 5 (nominati).	GENERATE_UUID() Nota: BigQuery restituisce 122 bit casuali. BigQuery supporta solo gli UUID di versione 4.
ZIPF(s, N, gen)	BigQuery non supporta un confronto diretto con ZIPF. di Snowflake

Funzioni di data e ora

La tabella seguente mostra le mappature tra data e ora di Snowflake comuni con i rispettivi equivalenti BigQuery. Le funzioni relative ai dati e al tempo di BigQuery includono le funzioni relative alle date, le funzioni relative a data e ora, le funzioni relative al tempo e le funzioni relative ai timestamp.

Snowflake	BigQuery
ADD_MONTHS(date, months)	CAST( DATE_ADD( date, INTERVAL integer MONTH ) AS TIMESTAMP )
CONVERT_TIMEZONE(source_tz, target_tz, source_timestamp) CONVERT_TIMEZONE(target_tz, source_timestamp)	PARSE_TIMESTAMP( "%c%z", FORMAT_TIMESTAMP( "%c%z", timestamp, target_timezone ) ) Nota: in BigQuery, source_timezone è sempre UTC
DATE_FROM_PARTS(year, month, day) Nota: Snowflake supporta le date con valori negativi e di overflow. Ad esempio, DATE_FROM_PARTS(2000, 1 + 24, 1) restituisce 1° gennaio 2002. Questa operazione non è supportata in BigQuery.	DATE(year, month, day) DATE(timestamp_expression[, timezone]) DATE(datetime_expression)
DATE_PART(part, dateOrTime) Nota: Snowflake supporta i tipi di parte ISO, nanosecondo ed epoca secondo/millisecondo/microsecondo/nanosecondo per giorno della settimana. BigQuery no. Consulta l'elenco completo dei tipi di ricambi Snowflake qui.	EXTRACT(part FROM dateOrTime) Nota: BigQuery supporta i tipi di parte settimana (<giorno della settimana>), microsecondo e millisecondo. Snowflake non lo sa. Consulta l'elenco completo dei tipi di parte di BigQuery qui e qui.
DATE_TRUNC(part, dateOrTime) Nota: Snowflake supporta il tipo di parte nanosecondo. BigQuery no. Consulta l'elenco completo dei tipi di ricambi Snowflake qui.	DATE_TRUNC(date, part) DATETIME_TRUNC(datetime, part) TIME_TRUNC(time, part) TIMESTAMP_TRUNC(timestamp, part[, timezone]) Nota: BigQuery supporta i tipi di parti settimana(<giorno della settimana>), settimana ISO e anno ISO. Snowflake non lo sa.
DATEADD(part, value, dateOrTime)	DATE_ADD(date, INTERVAL value part)
DATEDIFF( part, expression1, expression2 ) Nota: Snowflake supporta il calcolo della differenza tra due tipi di data, ora e timestamp in questa funzione.	DATE_DIFF( dateExpression1, dateExpression2, part ) DATETIME_DIFF( datetimeExpression1, datetimeExpression2, part ) TIME_DIFF( timeExpression1, timeExpression2, part ) TIMESTAMP_DIFF( timestampExpression1, timestampExpression2, part ) Nota: BigQuery supporta i tipi di parte settimana (<weekday>) e anno ISO.
DAYNAME(dateOrTimestamp)	FORMAT_DATE('%a', date) FORMAT_DATETIME('%a', datetime) FORMAT_TIMESTAMP('%a', timestamp)
EXTRACT(part FROM dateOrTime) Nota: Snowflake supporta i tipi di parti ISO del giorno della settimana, nanosecondo ed epoche in secondi/millisecondi/microsecondi/nanosecondi. al contrario di BigQuery. Consulta l'elenco completo dei tipi di ricambi Snowflake qui.	EXTRACT(part FROM dateOrTime) Nota: BigQuery supporta i tipi di componenti settimana(<giorno della settimana>), microsecondo e millisecondo. Snowflake no. Consulta l'elenco completo dei tipi di parte di BigQuery qui e qui.
[HOUR, MINUTE, SECOND](timeOrTimestamp)	EXTRACT(part FROM timestamp [AT THE ZONE timezone])
LAST_DAY(dateOrTime[, part])	DATE_SUB( DATE_TRUNC( DATE_ADD(date, INTERVAL 1 part), part), INTERVAL 1 DAY)
MONTHNAME(dateOrTimestamp)	FORMAT_DATE('%b', date) FORMAT_DATETIME('%b', datetime) FORMAT_TIMESTAMP('%b', timestamp)
NEXT_DAY(dateOrTime, dowString)	DATE_ADD( DATE_TRUNC( date, WEEK(dowString)), INTERVAL 1 WEEK) Nota: potrebbe essere necessario riformattare dowString. Ad esempio, "su" di Snowflake sarà "SUNDAY" di BigQuery.
PREVIOUS_DAY(dateOrTime, dowString)	DATE_TRUNC( date, WEEK(dowString) ) Nota: potrebbe essere necessario riformattare la stringa dow. Ad esempio, "su" di Snowflake sarà "SUNDAY" di BigQuery.
TIME_FROM_PARTS(hour, minute, second[, nanosecond) Nota: Snowflake supporta i tempi di overflow. Ad esempio, TIME_FROM_PARTS(0, 100, 0) restituisce 01:40:00... Questa operazione non è supportata in BigQuery. BigQuery non supporta i nanosecondi.	TIME(hour, minute, second) TIME(timestamp, [timezone]) TIME(datetime)
TIME_SLICE(dateOrTime, sliceLength, part[, START] TIME_SLICE(dateOrTime, sliceLength, part[, END]	DATE_TRUNC( DATE_SUB(CURRENT_DATE(), INTERVAL value MONTH), MONTH) DATE_TRUNC( DATE_ADD(CURRENT_DATE(), INTERVAL value MONTH), MONTH) Nota: BigQuery non supporta un confronto diretto ed esatto con TIME_SLICE di Snowflake. Utilizza DATETINE_TRUNC, TIME_TRUNC, TIMESTAMP_TRUNC per il tipo di dati appropriato.
TIMEADD(part, value, dateOrTime)	TIME_ADD(time, INTERVAL value part)
TIMEDIFF( part, expression1, expression2, ) Nota: Snowflake supporta il calcolo della differenza tra due tipi di date, ore e timestamp in questa funzione.	DATE_DIFF( dateExpression1, dateExpression2, part ) DATETIME_DIFF( datetimeExpression1, datetimeExpression2, part ) TIME_DIFF( timeExpression1, timeExpression2, part ) TIMESTAMP_DIFF( timestampExpression1, timestampExpression2, part ) Nota: BigQuery supporta i tipi di parte settimana (<weekday>) e anno ISO.
TIMESTAMP_[LTZ, NTZ, TZ _]FROM_PARTS (year, month, day, hour, second [, nanosecond][, timezone])	TIMESTAMP( string_expression[, timezone] | date_expression[, timezone] | datetime_expression[, timezone] ) Nota: BigQuery richiede che i timestamp vengano inseriti come tipi STRING. Esempio: "2008-12-25 15:30:00"
TIMESTAMPADD(part, value, dateOrTime)	TIMESTAMPADD(timestamp, INTERVAL value part)
TIMESTAMPDIFF( part, expression1, expression2, ) Nota: Snowflake supporta il calcolo della differenza tra due tipi di date, ore e timestamp in questa funzione.	DATE_DIFF( dateExpression1, dateExpression2, part ) DATETIME_DIFF( datetimeExpression1, datetimeExpression2, part ) TIME_DIFF( timeExpression1, timeExpression2, part ) TIMESTAMP_DIFF( timestampExpression1, timestampExpression2, part ) Nota: BigQuery supporta i tipi di parti settimana(<weekday>) e anno ISO.
TRUNC(dateOrTime, part) Nota: Snowflake supporta il tipo di parte nanosecondo. BigQuery no. Consulta l'elenco completo dei tipi di ricambi Snowflake qui.	DATE_TRUNC(date, part) DATETIME_TRUNC(datetime, part) TIME_TRUNC(time, part) TIMESTAMP_TRUNC(timestamp, part[, timezone]) Nota: BigQuery supporta i tipi di parti settimana(<giorno della settimana>), settimana ISO e anno ISO. Snowflake no.
[YEAR*, DAY*, WEEK*, MONTH, QUARTER](dateOrTimestamp)	EXTRACT(part FROM timestamp [AT THE ZONE timezone])

BigQuery offre anche le seguenti funzioni di data e ora, che non hanno un analogo diretto in Snowflake:

DATE_SUB PARSE_DATE DATETIME_ADD PARSE_DATETIME PARSE_TIME TIMESTAMP_SUB TIMESTAMP_SECONDS UNIX_SECONDS	DATE_FROM_UNIX_DATE UNIX_DATE DATETIME_SUB TIME_SUB STRING FORMAT_TIMESTAMP TIMESTAMP_MILLIS UNIX_MILLIS	FORMAT_DATE DATETIME FORMAT_DATETIME FORMAT_TIME TIMESTAMP_ADD PARSE_TIMESTAMP TIMESTAMP_MICROS UNIX_MICROS

Schema di informazioni e funzioni tabella

BigQuery non supporta concettualmente molte delle funzioni di tabelle e dello schema di informazioni di Snowflake. Snowflake offre lo schema di informazioni e le funzioni di tabella seguenti, che non hanno un analogo diretto in BigQuery:

• AUTOMATIC_CLUSTERING_HISTORY
• COPY_HISTORY
• DATA_TRANSFER_HISTORY
• DATABASE_REFRESH_HISTORY
• DATABASE_REFRESH_PROGRESS, DATABASE_REFRESH_PROGRESS_BY_JOB
• DATABASE_STORAGE_USAGE_HISTORY
• EXTERNAL_TABLE_FILES
• EXTERNAL_TABLE_FILE_REGISTRATION_HISTORY
• LOGIN_HISTORY, LOGIN_HISTORY_BY_USER
• MATERIALIZED_VIEW_REFRESH_HISTORY
• PIPE_USAGE_HISTORY
• REPLICATION_USAGE_HISTORY
• STAGE_STORAGE_USAGE_HISTORY
• TASK_DEPENDENTS
• VALIDATE_PIPE_LOAD
• WAREHOUSE_LOAD_HISTORY
• WAREHOUSE_METERING_HISTORY

Di seguito è riportato un elenco di funzioni di schema e tabella di BigQuery e Snowflake associate.

Snowflake	BigQuery
QUERY_HISTORY QUERY_HISTORY_BY_*	INFORMATION_SCHEMA.JOBS_BY_* Nota: non è un'alternativa diretta.
TASK_HISTORY	INFORMATION_SCHEMA.JOBS_BY_* Nota: non è un'alternativa diretta.

BigQuery offre le seguenti funzioni di schema di informazioni e tabella, che non hanno un analogo diretto in Snowflake:

• INFORMATION_SCHEMA.SCHEMATA
• INFORMATION_SCHEMA.ROUTINES
• INFORMATION_SCHEMA.TABLES
• INFORMATION_SCHEMA.VIEWS

Funzioni numeriche

La tabella seguente mostra le mappature tra le funzioni numeriche comuni di Snowflake e i relativi equivalenti di BigQuery.

Snowflake	BigQuery
ABS(expression)	ABS(expression)
ACOS(expression)	ACOS(expression)
ACOSH(expression)	ACOSH(expression)
ASIN(expression)	ASIN(expression)
ASINH(expression)	ASINH(expression)
ATAN(expression)	ATAN(expression)
ATAN2(y, x)	ATAN2(y, x)
ATANH(expression)	ATANH(expression)
CBRT(expression)	POW(expression, ⅓)
CEIL(expression [, scale])	CEIL(expression) Nota: CEIL di BigQuery non supporta la possibilità di indicare la precisione o la scala. ROUND non consente di specificare l'arrotondamento per eccesso.
COS(expression)	COS(expression)
COSH(expression)	COSH(expression)
COT(expression)	1/TAN(expression)
DEGREES(expression)	(expression)*(180/ACOS(-1))
EXP(expression)	EXP(expression)
FACTORIAL(expression)	BigQuery non ha un'alternativa diretta a FACTORIAL di Snowflake. Utilizza una funzione definita dall'utente.
FLOOR(expression [, scale])	FLOOR(expression) Nota: l'elemento FLOOR di BigQuery non supporta la possibilità di indicare la precisione o la scalabilità. ROUND non consente di specificare l'arrotondamento per eccesso. TRUNC ha un rendimento simile ai numeri positivi, ma non ai numeri negativi, in quanto valuta il valore assoluto.
HAVERSINE(lat1, lon1, lat2, lon2)	ST_DISTANCE( ST_GEOGPOINT(lon1, lat1), ST_GEOGPOINT(lon2, lat2) )/1000 Nota: non è una corrispondenza esatta, ma è abbastanza simile.
LN(expression)	LN(expression)
LOG(base, expression)	LOG(expression [,base]) LOG10(expression) Nota:la base predefinita per LOG è 10.
MOD(expression1, expression2)	MOD(expression1, expression2)
PI()	ACOS(-1)
POW(x, y) POWER(x, y)	POW(x, y) POWER(x, y)
RADIANS(expression)	(expression)*(ACOS(-1)/180)
ROUND(expression [, scale])	ROUND(expression, [, scale])
SIGN(expression)	SIGN(expression)
SIN(expression)	SIN(expression)
SINH(expression)	SINH(expression)
SQRT(expression)	SQRT(expression)
SQUARE(expression)	POW(expression, 2)
TAN(expression)	TAN(expression)
TANH(expression)	TANH(expression)
TRUNC(expression [, scale]) TRUNCATE(expression [, scale])	TRUNC(expression [, scale]) Nota: il valore restituito da BigQuery deve essere inferiore all'espressione. a cui non è supportato.

BigQuery offre anche le seguenti funzioni matematiche, che non hanno un analogo diretto in Snowflake:

• IS_INF
• IS_NAN
• IEEE_DIVIDE
• DIV
• SAFE_DIVIDE
• SAFE_MULTIPLY
• SAFE_NEGATE
• SAFE_ADD
• SAFE_SUBTRACT
• RANGE_BUCKET

Funzioni di dati semistrutturati

Snowflake	BigQuery
ARRAY_APPEND	Funzione personalizzata definita dall'utente
ARRAY_CAT	ARRAY_CONCAT
ARRAY_COMPACT	Funzione personalizzata definita dall'utente
ARRAY_CONSTRUCT	[ ]
ARRAY_CONSTRUCT_COMPACT	Funzione personalizzata definita dall'utente
ARRAY_CONTAINS	Funzione personalizzata definita dall'utente
ARRAY_INSERT	Funzione personalizzata definita dall'utente
ARRAY_INTERSECTION	Funzione personalizzata definita dall'utente
ARRAY_POSITION	Funzione personalizzata definita dall'utente
ARRAY_PREPEND	Funzione personalizzata definita dall'utente
ARRAY_SIZE	ARRAY_LENGTH
ARRAY_SLICE	Funzione personalizzata definita dall'utente
ARRAY_TO_STRING	ARRAY_TO_STRING
ARRAYS_OVERLAP	Funzione personalizzata definita dall'utente
AS_<object_type>	CAST
AS_ARRAY	CAST
AS_BINARY	CAST
AS_BOOLEAN	CAST
AS_CHAR , AS_VARCHAR	CAST
AS_DATE	CAST
AS_DECIMAL , AS_NUMBER	CAST
AS_DOUBLE , AS_REAL	CAST
AS_INTEGER	CAST
AS_OBJECT	CAST
AS_TIME	CAST
AS_TIMESTAMP_*	CAST
CHECK_JSON	Funzione personalizzata definita dall'utente
CHECK_XML	Funzione personalizzata definita dall'utente
FLATTEN	UNNEST
GET	Funzione personalizzata definita dall'utente
GET_IGNORE_CASE	Funzione personalizzata definita dall'utente
GET_PATH , :	Funzione personalizzata definita dall'utente
IS_<object_type>	Funzione personalizzata definita dall'utente
IS_ARRAY	Funzione personalizzata definita dall'utente
IS_BINARY	Funzione personalizzata definita dall'utente
IS_BOOLEAN	Funzione personalizzata definita dall'utente
IS_CHAR , IS_VARCHAR	Funzione personalizzata definita dall'utente
IS_DATE , IS_DATE_VALUE	Funzione personalizzata definita dall'utente
IS_DECIMAL	Funzione personalizzata definita dall'utente
IS_DOUBLE , IS_REAL	Funzione personalizzata definita dall'utente
IS_INTEGER	Funzione personalizzata definita dall'utente
IS_OBJECT	Funzione personalizzata definita dall'utente
IS_TIME	Funzione personalizzata definita dall'utente
IS_TIMESTAMP_*	Funzione personalizzata definita dall'utente
OBJECT_CONSTRUCT	Funzione personalizzata definita dall'utente
OBJECT_DELETE	Funzione personalizzata definita dall'utente
OBJECT_INSERT	Funzione personalizzata definita dall'utente
PARSE_JSON	JSON_EXTRACT
PARSE_XML	Funzione personalizzata definita dall'utente
STRIP_NULL_VALUE	Funzione personalizzata definita dall'utente
STRTOK_TO_ARRAY	SPLIT
TRY_PARSE_JSON	Funzione personalizzata definita dall'utente
TYPEOF	Funzione personalizzata definita dall'utente
XMLGET	Funzione personalizzata definita dall'utente

Funzioni di stringa e binarie

Snowflake	BigQuery
string1 || string2	CONCAT(string1, string2)
ASCII	TO_CODE_POINTS(string1)[OFFSET(0)]
BASE64_DECODE_BINARY	SAFE_CONVERT_BYTES_TO_STRING( FROM_BASE64(<bytes_input>) )
BASE64_DECODE_STRING	SAFE_CONVERT_BYTES_TO_STRING( FROM_BASE64(<string1>) )
BASE64_ENCODE	TO_BASE64( SAFE_CAST(<string1> AS BYTES) )
BIT_LENGTH	BYTE_LENGTH * 8 CHARACTER_LENGTH
CHARINDEX(substring, string)	STRPOS(string, substring)
CHR,CHAR	CODE_POINTS_TO_STRING([number])
COLLATE	Funzione personalizzata definita dall'utente
COLLATION	Funzione personalizzata definita dall'utente
COMPRESS	Funzione personalizzata definita dall'utente
CONCAT(string1, string2)	CONCAT(string1, string2) Nota: CONCAT(...) di BigQuery supporta la concatenazione di un numero qualsiasi di stringhe.
CONTAINS	Funzione personalizzata definita dall'utente
DECOMPRESS_BINARY	Funzione personalizzata definita dall'utente
DECOMPRESS_STRING	Funzione personalizzata definita dall'utente
EDITDISTANCE	Funzione personalizzata definita dall'utente
ENDSWITH	Funzione personalizzata definita dall'utente
HEX_DECODE_BINARY	SAFE_CONVERT_BYTES_TO_STRING( FROM_HEX(<string1>)
HEX_DECODE_STRING	SAFE_CONVERT_BYTES_TO_STRING( FROM_HEX(<string1>)
HEX_ENCODE	TO_HEX( SAFE_CAST(<string1> AS BYTES))
ILIKE	Funzione personalizzata definita dall'utente
ILIKE ANY	Funzione personalizzata definita dall'utente
INITCAP	INITCAP
INSERT	Funzione personalizzata definita dall'utente
LEFT	Funzione definita dall'utente
LENGTH	LENGTH(expression)
LIKE	LIKE
LIKE ALL	Funzione personalizzata definita dall'utente
LIKE ANY	Funzione personalizzata definita dall'utente
LOWER	LOWER(string)
LPAD	LPAD(string1, length[, string2])
LTRIM	LTRIM(string1, trim_chars)
MD5,MD5_HEX	MD5(string)
MD5_BINARY	Funzione personalizzata definita dall'utente
OCTET_LENGTH	Funzione personalizzata definita dall'utente
PARSE_IP	Funzione personalizzata definita dall'utente
PARSE_URL	Funzione personalizzata definita dall'utente
POSITION	STRPOS(string, substring)
REPEAT	REPEAT(string, integer)
REPLACE	REPLACE(string1, old_chars, new_chars)
REVERSE number_characters )	REVERSE(expression)
RIGHT	Funzione definita dall'utente
RPAD	RPAD
RTRIM	RTRIM(string, trim_chars)
RTRIMMED_LENGTH	Funzione personalizzata definita dall'utente
SHA1,SHA1_HEX	SHA1(string)
SHA1_BINARY	Funzione personalizzata definita dall'utente
SHA2,SHA2_HEX	Funzione personalizzata definita dall'utente
SHA2_BINARY	Funzione personalizzata definita dall'utente
SOUNDEX	Funzione personalizzata definita dall'utente
SPACE	Funzione personalizzata definita dall'utente
SPLIT	SPLIT
SPLIT_PART	Funzione personalizzata definita dall'utente
SPLIT_TO_TABLE	Funzione personalizzata definita dall'utente
STARTSWITH	Funzione personalizzata definita dall'utente
STRTOK	SPLIT(instring, delimiter)[ORDINAL(tokennum)] Nota: l'intero parametro di stringa del delimitatore viene utilizzato come singolo delimitatore. Il delimitatore predefinito è una virgola.
STRTOK_SPLIT_TO_TABLE	Funzione personalizzata definita dall'utente
SUBSTR,SUBSTRING	SUBSTR
TRANSLATE	Funzione personalizzata definita dall'utente
TRIM	TRIM
TRY_BASE64_DECODE_BINARY	Funzione personalizzata definita dall'utente
TRY_BASE64_DECODE_STRING	SUBSTR(string, 0, integer)
TRY_HEX_DECODE_BINARY	SUBSTR(string, -integer)
TRY_HEX_DECODE_STRING	LENGTH(expression)
UNICODE	Funzione personalizzata definita dall'utente
UPPER	UPPER

Funzioni stringa (espressioni regolari)

Snowflake	BigQuery
REGEXP	IF(REGEXP_CONTAINS,1,0)=1
REGEXP_COUNT	ARRAY_LENGTH( REGEXP_EXTRACT_ALL( source_string, pattern ) ) Se position è specificato: ARRAY_LENGTH( REGEXP_EXTRACT_ALL( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern ) ) Nota: BigQuery fornisce il supporto per le espressioni regolari utilizzando la libreria re2; consulta la documentazione per la sintassi delle espressioni regolari.
REGEXP_INSTR	IFNULL( STRPOS( source_string, REGEXP_EXTRACT( source_string, pattern) ), 0) Se è specificato position: IFNULL( STRPOS( SUBSTR(source_string, IF(position <= 0, 1, position)), REGEXP_EXTRACT( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern) ) + IF(position <= 0, 1, position) - 1, 0) Se è specificato occurrence: IFNULL( STRPOS( SUBSTR(source_string, IF(position <= 0, 1, position)), REGEXP_EXTRACT_ALL( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern )[SAFE_ORDINAL(occurrence)] ) + IF(position <= 0, 1, position) - 1, 0) Nota: BigQuery fornisce il supporto delle espressioni regolari utilizzando la libreria re2; consulta la documentazione per la sintassi delle espressioni regolari.
REGEXP_LIKE	IF(REGEXP_CONTAINS,1,0)=1
REGEXP_REPLACE	REGEXP_REPLACE( source_string, pattern, "" ) Se replace_string è specificato: REGEXP_REPLACE( source_string, pattern, replace_string ) Se è specificato position: CASE WHEN position > LENGTH(source_string) THEN source_string WHEN position <= 0 THEN REGEXP_REPLACE( source_string, pattern, "" ) ELSE CONCAT( SUBSTR( source_string, 1, position - 1), REGEXP_REPLACE( SUBSTR(source_string, position), pattern, replace_string ) ) END Nota: BigQuery fornisce il supporto delle espressioni regolari utilizzando la libreria re2; consulta la documentazione per la sintassi delle espressioni regolari.
REGEXP_SUBSTR	REGEXP_EXTRACT( source_string, pattern ) Se position è specificato: REGEXP_EXTRACT( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern ) Se è specificato occurrence: REGEXP_EXTRACT_ALL( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern )[SAFE_ORDINAL(occurrence)] Nota: BigQuery fornisce il supporto per le espressioni regolari utilizzando la libreria re2; consulta la documentazione per la sintassi delle espressioni regolari.
RLIKE	IF(REGEXP_CONTAINS,1,0)=1

Funzioni di sistema

Snowflake	BigQuery
SYSTEM$ABORT_SESSION	Funzione personalizzata definita dall'utente
SYSTEM$ABORT_TRANSACTION	Funzione personalizzata definita dall'utente
SYSTEM$CANCEL_ALL_QUERIES	Funzione personalizzata definita dall'utente
SYSTEM$CANCEL_QUERY	Funzione personalizzata definita dall'utente
SYSTEM$CLUSTERING_DEPTH	Funzione personalizzata definita dall'utente
SYSTEM$CLUSTERING_INFORMATION	Funzione personalizzata definita dall'utente
SYSTEM$CLUSTERING_RATIO — Deprecated	Funzione personalizzata definita dall'utente
SYSTEM$CURRENT_USER_TASK_NAME	Funzione personalizzata definita dall'utente
SYSTEM$DATABASE_REFRESH_HISTORY	Funzione personalizzata definita dall'utente
SYSTEM$DATABASE_REFRESH_PROGRESS , SYSTEM$DATABASE_REFRESH_PROGRESS_BY_JOB	Funzione personalizzata definita dall'utente
SYSTEM$GET_AWS_SNS_IAM_POLICY	Funzione personalizzata definita dall'utente
SYSTEM$GET_PREDECESSOR_RETURN_VALUE	Funzione personalizzata definita dall'utente
SYSTEM$LAST_CHANGE_COMMIT_TIME	Funzione personalizzata definita dall'utente
SYSTEM$PIPE_FORCE_RESUME	Funzione personalizzata definita dall'utente
SYSTEM$PIPE_STATUS	Funzione personalizzata definita dall'utente
SYSTEM$SET_RETURN_VALUE	Funzione personalizzata definita dall'utente
SYSTEM$SHOW_OAUTH_CLIENT_SECRETS	Funzione personalizzata definita dall'utente
SYSTEM$STREAM_GET_TABLE_TIMESTAMP	Funzione personalizzata definita dall'utente
SYSTEM$STREAM_HAS_DATA	Funzione personalizzata definita dall'utente
SYSTEM$TASK_DEPENDENTS_ENABLE	Funzione personalizzata definita dall'utente
SYSTEM$TYPEOF	Funzione personalizzata definita dall'utente
SYSTEM$USER_TASK_CANCEL_ONGOING_EXECUTIONS	Funzione personalizzata definita dall'utente
SYSTEM$WAIT	Funzione personalizzata definita dall'utente
SYSTEM$WHITELIST	Funzione personalizzata definita dall'utente
SYSTEM$WHITELIST_PRIVATELINK	Funzione personalizzata definita dall'utente

Funzioni tabella

Snowflake		BigQuery
GENERATOR		Funzione personalizzata definita dall'utente
GET_OBJECT_REFERENCES		Funzione personalizzata definita dall'utente
RESULT_SCAN		Funzione personalizzata definita dall'utente
VALIDATE		Funzione personalizzata definita dall'utente

Funzioni di utilità e hash

Snowflake		BigQuery
GET_DDL		Richiesta di funzionalità
HASH		HASH è una funzione proprietaria specifica di Snowflake. Non può essere tradotto senza conoscere la logica di base utilizzata da Snowflake.

Funzioni finestra

Snowflake		BigQuery
CONDITIONAL_CHANGE_EVENT		Funzione personalizzata definita dall'utente
CONDITIONAL_TRUE_EVENT		Funzione personalizzata definita dall'utente
CUME_DIST		CUME_DIST
DENSE_RANK		DENSE_RANK
FIRST_VALUE		FIRST_VALUE
LAG		LAG
LAST_VALUE		LAST_VALUE
LEAD		LEAD
NTH_VALUE		NTH_VALUE
NTILE		NTILE
PERCENT_RANK		PERCENT_RANK
RANK		RANK
RATIO_TO_REPORT		Funzione personalizzata definita dall'utente
ROW_NUMBER		ROW_NUMBER
WIDTH_BUCKET		Funzione personalizzata definita dall'utente

BigQuery supporta anche SAFE_CAST(espressione AS tiponome), che restituisce NULL se BigQuery non è in grado di eseguire un trasferimento (ad esempio, SAFE_CAST("mela" AS INT64) restituisce NULL).

Operatori

Le sezioni seguenti elencano gli operatori Snowflake e i relativi equivalenti BigQuery.

Operatori aritmetici

La tabella seguente mostra le mappature tra Snowflake operatori aritmetici con gli equivalenti BigQuery.

Snowflake	BigQuery
(Unary) (+'5')	CAST("5" AS NUMERIC)
a + b	a + b
(Unary) (-'5')	(-1) * CAST("5" AS NUMERIC) Nota: BigQuery supporta il meno unario standard, ma non converte gli interi in formato stringa in tipo INT64, NUMERIC o FLOAT64.
a - b	a - b
date1 - date2 date1 - 365	DATE_DIFF(date1, date2, date_part) DATE_SUB(date1, date2, date_part)
a * b	a * b
a / b	a / b
a % b	MOD(a, b)

Per visualizzare i dettagli della scala e della precisione Snowflake durante l'esecuzione di operazioni aritmetiche operazioni, guarda il file Snowflake documentazione.

Operatori di confronto

Gli operatori di confronto di Snowflake e gli operatori di confronto di BigQuery sono gli stessi.

Operatori logici/booleani

Fiocco di neve operatori logici e booleani e BigQuery operatori logici/booleani sono le stesse.

Operatori Set

La tabella seguente mostra le mappature tra gli operatori di set di Snowflake e i relativi equivalenti di BigQuery.

Snowflake	BigQuery
SELECT ... INTERSECT SELECT ...	SELECT ... INTERSECT DISTINCT SELECT...
SELECT ... MINUS SELECT ... SELECT ... EXCEPT SELECT … Nota: MINUS e EXCEPT sono sinonimi.	SELECT ... EXCEPT DISTINCT SELECT ...
SELECT ... UNION SELECT ... SELECT ... UNION ALL SELECT ...	SELECT ... UNION DISTINCT SELECT ... SELECT ... UNION ALL SELECT ...

Operatori di sottoquery

La tabella seguente mostra le mappature tra gli operatori di sottoquery di Snowflake e i relativi equivalenti di BigQuery.

Snowflake	BigQuery
SELECT ... FROM ... WHERE col <operator> ALL … SELECT ... FROM ... WHERE col <operator> ANY ...	BigQuery non supporta un'alternativa diretta a ALL/ANY di Snowflake.
SELECT ... FROM ... WHERE [NOT] EXISTS...	SELECT ... FROM ... WHERE [NOT] EXISTS...
SELECT ... FROM ... WHERE [NOT] IN...	SELECT ... FROM ... WHERE [NOT] IN...
SELECT * FROM table1 UNION SELECT * FROM table2 EXCEPT SELECT * FROM table3	SELECT * FROM table1 UNION ALL ( SELECT * FROM table2 EXCEPT SELECT * FROM table3 ) Nota: BigQuery richiede le parentesi per separare le diverse operazioni di impostazione. Se lo stesso operatore di insieme viene ripetuto, le parentesi non sono necessarie.

Sintassi DML

Questa sezione illustra le differenze nella sintassi del linguaggio di gestione dei dati tra Snowflake e BigQuery.

INSERT dichiarazione

Snowflake offre una parola chiave DEFAULT configurabile per le colonne. In BigQuery, il valore DEFAULT per le colonne con valori null è NULL e DEFAULT non è supportato per le colonne obbligatorie. La maggior parte delle istruzione INSERT di Snowflake è compatibile con BigQuery. La tabella seguente mostra le eccezioni.

Snowflake	BigQuery
INSERT [OVERWRITE] INTO table VALUES [... | DEFAULT | NULL] ... Nota: BigQuery non supporta l'inserimento di oggetti JSON con un'INSERT istruzione.	INSERT [INTO] table (column1 [, ...]) VALUES (DEFAULT [, ...]) Nota: BigQuery non supporta un'alternativa diretta a OVERWRITE di Snowflake. Usa invece il criterio DELETE.
INSERT INTO table (column1 [, ...]) SELECT... FROM ...	INSERT [INTO] table (column1, [,...]) SELECT ... FROM ...
INSERT [OVERWRITE] ALL <intoClause> ... INSERT [OVERWRITE] {FIRST | ALL} {WHEN condition THEN <intoClause>} [...] [ELSE <intoClause>] ... Nota: <intoClause> rappresenta il valore INSERT statement standard elencato sopra.	BigQuery non supporta i INSERTsmultitabelle condizionali e incondizionali.

BigQuery supporta anche l'inserimento di valori utilizzando una sottoquery (in cui uno dei valori viene calcolato utilizzando una sottoquery), che non è supportato in Snowflake. Ad esempio:

INSERT INTO table (column1, column2)
VALUES ('value_1', (
  SELECT column2
  FROM table2
))

COPY dichiarazione

Snowflake supporta la copia dei dati dai file delle fasi in una tabella esistente e da una tabella a un'area intermedia interna denominata, a un'area intermedia esterna denominata e a una posizione esterna (Amazon S3, Google Cloud Storage o Microsoft Azure).

• COPY INTO <table>
• COPY INTO <location>

BigQuery non utilizza il comando SQL COPY per caricare i dati, ma puoi utilizzare uno dei vari strumenti e opzioni non SQL per e caricare i dati in tabelle BigQuery. Puoi anche utilizzare sink di pipeline di dati forniti in Apache Spark o Apache Beam per scrivere dati in BigQuery.

UPDATE dichiarazione

La maggior parte delle istruzioni UPDATE di Snowflake è compatibile con BigQuery. La la seguente tabella mostra le eccezioni.

Snowflake		BigQuery
UPDATE table SET col = value [,...] [FROM ...] [WHERE ...]		UPDATE table SET column = expression [,...] [FROM ...] WHERE TRUE Nota: tutte le istruzioni UPDATE in BigQuery richiedono una parola chiave WHERE, seguita da una condizione.

DELETE e TRUNCATE TABLE estratti conto

Le istruzioni DELETE e TRUNCATE TABLE sono entrambi modi per rimuovere righe da una tabella senza influire sullo schema o sugli indici della tabella.

In Snowflake, sia DELETE sia TRUNCATE TABLE mantengono i dati eliminati utilizzando la funzionalità di viaggio nel tempo di Snowflake a fini di recupero per il periodo di conservazione dei dati. Tuttavia, DELETE non elimina la cronologia e il caricamento dei file esterni metadati.

In BigQuery, l'istruzione DELETE deve avere una clausola WHERE. Per ulteriori informazioni su DELETE in BigQuery, consulta EsempiDELETEdi BigQuery nella documentazione di DML.

Snowflake	BigQuery
DELETE FROM table_name [USING ...] [WHERE ...] TRUNCATE [TABLE] [IF EXISTS] table_name	DELETE [FROM] table_name [alias] WHERE ... Nota: le istruzioni DELETE BigQuery richiedono una WHERE clausola.

Istruzione MERGE

L'istruzione MERGE può combinare le operazioni INSERT, UPDATE e DELETE in un unico "superiore" ed eseguire le operazioni automaticamente. La L'operazione MERGE deve corrispondere al massimo a una riga di origine per ogni riga target.

Le tabelle BigQuery hanno un limite di 1000 istruzioni DML al giorno, quindi dovrebbe consolidare in modo ottimale le istruzioni INSERT, UPDATE e DELETE in un'unica Istruzione MERGE, come illustrato nella seguente tabella:

Snowflake	BigQuery
MERGE INTO target USING source ON target.key = source.key WHEN MATCHED AND source.filter = 'Filter_exp' THEN UPDATE SET target.col1 = source.col1, target.col1 = source.col2, ... Nota: Snowflake supporta un parametro di sessione ERROR_ON_NONDETERMINISTIC_MERGE per gestire i risultati non deterministici.	MERGE target USING source ON target.key = source.key WHEN MATCHED AND source.filter = 'filter_exp' THEN UPDATE SET target.col1 = source.col1, target.col2 = source.col2, ... Nota: se vuoi aggiornare tutte le colonne, devono essere elencate tutte le colonne.

GET e LIST estratti conto

L'istruzione GET scarica i file di dati da una delle seguenti fasi di Snowflake in una directory/cartella locale su un computer client:

• Fase interna denominata
• Fase interna per una tabella specificata
• Fase interna per l'utente corrente

La LIST (LS) restituisce un elenco di file archiviati in un'area intermedia (ovvero caricati da un file system locale o scaricati da una tabella) in una delle seguenti opzioni Fasi Snowflake:

• Fase interna denominata
• Fase esterna con nome
• Fase per una tabella specificata
• Fase per l'utente corrente

BigQuery non supporta il concetto di staging e non ha equivalenti di GET e LIST.

Estratti conto PUT e REMOVE

La PUT l'istruzione carica i file di dati da una directory/cartella locale da un computer client a una delle seguenti fasi di Snowflake:

• Fase interna denominata
• Fase interna per una tabella specificata
• Fase interna per l'utente corrente

L'istruzione REMOVE (RM) rimuove i file che sono stati sottoposti a staging in una delle seguenti fasi interne di Snowflake:

• Fase interna denominata
• Fase per una tabella specificata
• Fase per l'utente corrente

BigQuery non supporta il concetto di staging e non ha equivalenti di PUT e REMOVE.

Sintassi DDL

Questa sezione illustra le differenze nella sintassi del linguaggio di definizione dei dati tra Snowflake e BigQuery.

DDL Database, schema e condivisione

La maggior parte della terminologia di Snowflake corrisponde a quella di BigQuery, ad eccezione del fatto che Il database Snowflake è simile al set di dati BigQuery. Consulta la mappatura dettagliata della terminologia di Snowflake a BigQuery.

Istruzione CREATE DATABASE

Snowflake supporta la creazione e la gestione di un database tramite comandi di gestione del database, mentre BigQuery offre più opzioni, come l'utilizzo della console, della CLI, delle librerie client e così via per la creazione di set di dati. In questa sezione verranno utilizzati i comandi della CLI di BigQuery corrispondenti ai comandi di Snowflake per risolvere le differenze.

Snowflake	BigQuery
CREATE DATABASE <name> Nota: Snowflake fornisce questi requisiti per la denominazione dei database. Il nome può contenere solo 255 caratteri.	bq mk <name> Nota: BigQuery ha requisiti di denominazione dei set di dati simili a Snowflake, tranne per il fatto che consente 1024 caratteri nel nome.
CREATE OR REPLACE DATABASE <name>	La sostituzione del set di dati non è supportata in BigQuery.
CREATE TRANSIENT DATABASE <name>	La creazione di un set di dati temporaneo non è supportata in BigQuery.
CREATE DATABASE IF NOT EXISTS <name>	Concetto non supportato in BigQuery
CREATE DATABASE <name> CLONE <source_db> [ { AT | BEFORE } ( { TIMESTAMP => <timestamp> | OFFSET => <time_difference> | STATEMENT => <id> } ) ]	La clonazione dei set di dati non è ancora supportata in BigQuery.
CREATE DATABASE <name> DATA_RETENTION_TIME_IN_DAYS = <num>	Lo spostamento cronologico a livello del set di dati non è supportato in BigQuery. Tuttavia, è supportata la corsa cronologica per i risultati di tabelle e query.
CREATE DATABASE <name> DEFAULT_DDL_COLLATION = '<collation_specification>'	Le regole di confronto in DDL non sono supportate in BigQuery.
CREATE DATABASE <name> COMMENT = '<string_literal>'	bq mk \ --description "<string_literal>" \ <name>
CREATE DATABASE <name> FROM SHARE <provider_account>.<share_name>	La creazione di set di dati condivisi non è supportata in BigQuery. Tuttavia, gli utenti possono condividere il set di dati tramite la console/l'interfaccia utente dopo averlo creato.
CREATE DATABASE <name> AS REPLICA OF <region>.<account>.<primary_db_name> AUTO_REFRESH_MATERIALIZED_VIEWS_ON_SECONDARY = { TRUE | FALSE } Nota: Snowflake offre la possibilità di manutenzione automatica in background delle viste materializzate nel database secondario, che non è supportata in BigQuery.	bq mk --transfer_config \ --target_dataset = <name> \ --data_source = cross_region_copy \ --params=' {"source_dataset_id":"<primary_db_name>" ,"source_project_id":"<project_id>" ,"overwrite_destination_table":"true"}' Nota: BigQuery supporta la copia di set di dati tramite BigQuery Data Transfer Service. Visita questa pagina per conoscere i prerequisiti per la copia dei set di dati.

BigQuery offre anche le seguenti opzioni di comando bq mk, che non avere un analogo diretto in Snowflake:

• --location <dataset_location>
• --default_table_expiration <time_in_seconds>
• --default_partition_expiration <time_in_seconds>

Istruzione ALTER DATABASE

Questa sezione utilizzerà i comandi della CLI di BigQuery corrispondenti ai comandi di Snowflake per risolvere le differenze nelle istruzioni ALTER.

Snowflake	BigQuery
ALTER DATABASE [ IF EXISTS ] <name> RENAME TO <new_db_name>	La ridenominazione dei set di dati non è supportata in BigQuery, ma la copia dei set di dati è supportata.
ALTER DATABASE <name> SWAP WITH <target_db_name>	Lo scambio di set di dati non è supportato in BigQuery.
ALTER DATABASE <name> SET [DATA_RETENTION_TIME_IN_DAYS = <num>] [ DEFAULT_DDL_COLLATION = '<value>']	La gestione della conservazione e della compilazione dei dati a livello di set di dati non è supportata in BigQuery.
ALTER DATABASE <name> SET COMMENT = '<string_literal>'	bq update \ --description "<string_literal>" <name>
ALTER DATABASE <name> ENABLE REPLICATION TO ACCOUNTS <snowflake_region>.<account_name> [ , <snowflake_region>.<account_name> ... ]	Concetto non supportato in BigQuery.
ALTER DATABASE <name> DISABLE REPLICATION [ TO ACCOUNTS <snowflake_region>.<account_name> [ , <snowflake_region>.<account_name> ... ]]	Concetto non supportato in BigQuery.
ALTER DATABASE <name> SET AUTO_REFRESH_MATERIALIZED_VIEWS_ON_SECONDARY = { TRUE | FALSE }	Concetto non supportato in BigQuery.
ALTER DATABASE <name> REFRESH	Concetto non supportato in BigQuery.
ALTER DATABASE <name> ENABLE FAILOVER TO ACCOUNTS <snowflake_region>.<account_name> [ , <snowflake_region>.<account_name> ... ]	Concetto non supportato in BigQuery.
ALTER DATABASE <name> DISABLE FAILOVER [ TO ACCOUNTS <snowflake_region>.<account_name> [ , <snowflake_region>.<account_name> ... ]]	Concetto non supportato in BigQuery.
ALTER DATABASE <name> PRIMARY	Concetto non supportato in BigQuery.

DROP DATABASE dichiarazione

Questa sezione utilizzerà il comando della CLI BigQuery corrispondente al comando Snowflake per risolvere la differenza nell'istruzione DROP.

Snowflake	BigQuery
DROP DATABASE [ IF EXISTS ] <name> [ CASCADE | RESTRICT ] Nota: in Snowflake, l'eliminazione di un database non comporta la sua rimozione definitiva dal sistema. Una versione del database eliminato viene conservata per il numero di giorni specificato dal parametro DATA_RETENTION_TIME_IN_DAYS per il database.	bq rm -r -f -d <name> Where -r è la rimozione di tutti gli oggetti nel set di dati -f is to skip confirmation for execution -d indica il set di dati Nota: in BigQuery, l'eliminazione di un set di dati è definitiva. Inoltre, la ricorsione non è supportata a livello di set di dati, poiché tutti i dati e gli oggetti al suo interno vengono eliminati.

Snowflake supporta anche UNDROP DATASET che ripristina la versione più recente di un set di dati eliminato. Questo è attualmente non è supportata in BigQuery a livello del set di dati.

USE DATABASE dichiarazione

Snowflake offre la possibilità di impostare il database per una sessione utente utilizzando il comando USE DATABASE. In questo modo non è necessario specificare nomi di oggetti completi tramite comandi SQL. BigQuery non fornisce alcuna alternativa al comando USE DATABASE di Snowflake.

Istruzione SHOW DATABASE

Questa sezione utilizza il comando CLI BigQuery corrispondente al comando Snowflake per risolvere la differenza nell'istruzione SHOW.

Snowflake	BigQuery
SHOW DATABASES Nota: Snowflake offre un'unica opzione per elencare e mostrare i dettagli di tutti i database, inclusi quelli eliminati che si trovano nel periodo di conservazione.	bq ls --format=prettyjson e / o bq show <dataset_name> Nota: in BigQuery, il comando ls fornisce solo i nomi dei set di dati e informazioni di base, mentre il comando show fornisce dettagli come il timestamp dell'ultima modifica, le ACL e le etichette di un set di dati. Inoltre, BigQuery fornisce ulteriori dettagli sui set di dati tramite lo schema delle informazioni.
SHOW TERSE DATABASES Nota: con l'opzione TERSE, Snowflake consente di visualizzare solo informazioni/campi specifici sui set di dati.	Concetto non supportato in BigQuery.
SHOW DATABASES HISTORY	Il concetto di viaggio nel tempo non è supportato in BigQuery a livello di set di dati.
SHOW DATABASES [LIKE '<pattern>'] [STARTS WITH '<name_string>']	Il filtro dei risultati in base ai nomi del set di dati non è supportato in BigQuery. Tuttavia, il filtro per etichette è supportato.
SHOW DATABASES LIMIT <rows> [FROM '<name_string>'] Nota: per impostazione predefinita, Snowflake non limita il numero di risultati. Tuttavia, il valore di LIMIT non può superare 10.000.	bq ls \ --max_results <rows> Nota: per impostazione predefinita, BigQuery mostra solo 50 risultati.

BigQuery offre anche le seguenti opzioni di comando bq, che non hanno un analogo diretto in Snowflake:

• bq ls --format=pretty: restituisce risultati formattati di base
• *bq ls -a: *restituisce solo set di dati anonimi (quelli che iniziano con un trattino basso)
• bq ls --all: restituisce tutti i set di dati, inclusi quelli anonimi
• bq ls --filter labels.key:value: restituisce i risultati filtrati in base all'etichetta del set di dati
• bq ls --d: esclude i risultati dei moduli dei set di dati anonimi
• bq show --format=pretty: restituisce risultati di base dettagliati formattati per tutti i set di dati

Gestione di SCHEMA

Snowflake offre diverse di gestione degli schemi in modo simile ai suoi comandi di gestione dei database. Questo concetto di creazione e gestione dello schema non è supportato in BigQuery.

Tuttavia, BigQuery ti consente di specificare lo schema di una tabella quando carichi i dati in una tabella e quando crei una tabella vuota. In alternativa, puoi utilizza il rilevamento automatico dello schema per formati di dati supportati.

Gestione di SHARE

Snowflake fornisce più comandi di gestione delle quote simili ai comandi di gestione di database e schemi. Questo concetto di La creazione e la gestione della condivisione non sono supportate in BigQuery.

DDL tabella, visualizzazione e sequenza

Istruzione CREATE TABLE

La maggior parte delle istruzioni CREATE TABLE Snowflake è compatibile con BigQuery, ad eccezione dei seguenti elementi di sintassi, che non sono utilizzati BigQuery:

Snowflake	BigQuery
CREATE TABLE table_name ( col1 data_type1 NOT NULL, col2 data_type2 NULL, col3 data_type3 UNIQUE, col4 data_type4 PRIMARY KEY, col5 data_type5 ) Nota: i vincoli UNIQUE e PRIMARY KEY sono informativi e non vengono applicati dal sistema Snowflake.	CREATE TABLE table_name ( col1 data_type1 NOT NULL, col2 data_type2, col3 data_type3, col4 data_type4, col5 data_type5, )
CREATE TABLE table_name ( col1 data_type1[,...] table_constraints ) where table_constraints are: [UNIQUE(column_name [, ... ])] [PRIMARY KEY(column_name [, ...])] [FOREIGN KEY(column_name [, ...]) REFERENCES reftable [(refcolumn)] Nota: i vincoli UNIQUE e PRIMARY KEY sono informativi e non vengono applicati dal sistema Snowflake.	CREATE TABLE table_name ( col1 data_type1[,...] ) PARTITION BY column_name CLUSTER BY column_name [, ...] Nota: BigQuery non utilizza i vincoli di tabella UNIQUE, PRIMARY KEY o FOREIGN KEY. Per ottenere un'ottimizzazione simile a quella fornita da questi vincoli durante l'esecuzione delle query, partiziona e raggruppa le tabelle BigQuery. CLUSTER BY supporta fino a quattro colonne.
CREATE TABLE table_name LIKE original_table_name	Consulta questo esempio per imparare a utilizzare le tabelle INFORMATION_SCHEMA per copiare i nomi delle colonne, i tipi di dati e i vincoli NOT NULL in una nuova tabella.
CREATE TABLE table_name ( col1 data_type1 ) BACKUP NO Nota:in Snowflake, l'impostazione BACKUP NO è specificata per "risparmiare tempo di elaborazione durante la creazione di snapshot e il ripristino dagli snapshot e per ridurre lo spazio di archiviazione".	L'opzione di tabella BACKUP NO non viene utilizzata né è necessaria perché BigQuery conserva automaticamente fino a 7 giorni di versioni storiche di tutte le tabelle, senza alcun effetto sul tempo di elaborazione né sullo spazio di archiviazione fatturato.
CREATE TABLE table_name ( col1 data_type1 ) table_attributes dove table_attributes sono: [DISTSTYLE {AUTO|EVEN|KEY|ALL}] [DISTKEY (column_name)] [[COMPOUND|INTERLEAVED] SORTKEY (column_name [, ...])]	BigQuery supporta il clustering, che consente di memorizzare le chiavi in ordine.
CREATE TABLE table_name AS SELECT ...	CREATE TABLE table_name AS SELECT ...
CREATE TABLE IF NOT EXISTS table_name ...	CREATE TABLE IF NOT EXISTS table_name ...

BigQuery supporta anche l'istruzione DDL CREATE OR REPLACE TABLE che sovrascrive una tabella se esiste già.

L'istruzione CREATE TABLE di BigQuery supporta anche le seguenti clausole, che non hanno un equivalente Snowflake:

• PARTITION BY partition_statement
• CLUSTER BY clustering_column_list
• OPTIONS(table_options_list)

Per ulteriori informazioni su CREATE TABLE in BigQuery, consulta gli esempi di CREATE di BigQuery nella documentazione DML.

Istruzione ALTER TABLE

Questa sezione utilizzerà i comandi della CLI di BigQuery corrispondenti ai comandi di Snowflake per risolvere le differenze nelle istruzioni ALTER per le tabelle.

Snowflake	BigQuery
ALTER TABLE [ IF EXISTS ] <name> RENAME TO <new_name>	ALTER TABLE [IF EXISTS] <name> SET OPTIONS (friendly_name="<new_name>")
ALTER TABLE <name> SWAP WITH <target_db_name>	Lo scambio di tabelle non è supportato in BigQuery.
ALTER TABLE <name> SET [DEFAULT_DDL_COLLATION = '<value>']	La gestione delle regole di confronto dei dati per le tabelle non è supportata in BigQuery.
ALTER TABLE <name> SET [DATA_RETENTION_TIME_IN_DAYS = <num>]	ALTER TABLE [IF EXISTS] <name> SET OPTIONS (expiration_timestamp=<timestamp>)
ALTER TABLE <name> SET COMMENT = '<string_literal>'	ALTER TABLE [IF EXISTS] <name> SET OPTIONS (description='<string_literal>')

Inoltre, Snowflake offre opzioni di clustering, colonna e vincolo per modificare le tabelle non supportate da BigQuery.

DROP TABLE e UNDROP TABLE estratti conto

In questa sezione verrà utilizzato il comando della CLI BigQuery corrispondente al comando Snowflake per risolvere la differenza tra le istruzioni DROP e UNDROP.

Snowflake	BigQuery
DROP TABLE [IF EXISTS] <table_name> [CASCADE | RESTRICT] Nota: in Snowflake, l'eliminazione di una tabella non ne comporta la rimozione definitiva dal sistema. Una versione della tabella eliminata viene conservata per il numero di giorni specificato dal parametro DATA_RETENTION_TIME_IN_DAYS per il database.	bq rm -r -f -d <dataset_name>.<table_name> Where -r serve per rimuovere tutti gli oggetti nel set di dati -f serve per saltare la conferma per l'esecuzione -d indica il set di dati Nota: in BigQuery, anche l'eliminazione di una tabella non è permanente, ma al momento uno snapshot viene mantenuto solo per 7 giorni.
UNDROP TABLE <table_name>	bq cp \ <dataset_name>.<table_name>@<unix_timestamp> <dataset_name>.<new_table_name> Nota: in BigQuery, devi prima determinare un timestamp UNIX della data e dell'ora in cui la tabella esisteva (in millisecondi). Poi, copia in una nuova tabella la tabella corrispondente a quel timestamp. La nuova tabella deve avere un nome diverso da quello della tabella eliminata.

CREATE EXTERNAL TABLE dichiarazione

BigQuery consente di creare tabelle esterne permanenti e temporanee ed eseguire query sui dati direttamente da:

• Bigtable
• Cloud Storage
• Google Drive
• Cloud SQL (beta)

Snowflake consente di creare tabella esterna permanente che, quando viene eseguita una query, legge i dati da un insieme di uno o più file in un fase esterna.

Questa sezione utilizzerà il comando dell'interfaccia a riga di comando di BigQuery corrispondente Comando Snowflake per risolvere le differenze nell'istruzione CREATE EXTERNAL TABLE.

Snowflake	BigQuery
CREATE [OR REPLACE] EXTERNAL TABLE table ((<col_name> <col_type> AS <expr> ) | (<part_col_name> <col_type> AS <part_expr>)[ inlineConstraint ] [ , ... ] ) LOCATION = externalStage FILE_FORMAT = ({FORMAT_NAME='<file_format_name>' |TYPE=source_format [formatTypeOptions]}) Where: externalStage = @[namespace.]ext_stage_name[/path] Nota: Snowflake consente di eseguire il temporaneo dei file contenenti i dati da leggere e di specificare le opzioni di tipo di formato per le tabelle esterne. BigQuery, tranne il tipo XML, supporta tutti i tipi di formato Snowflake: CSV, JSON, AVRO, PARQUET e ORC.	[1] bq mk \ --external_table_definition=definition_file \ dataset.table OR [2] bq mk \ --external_table_definition=schema_file@source_format={Cloud Storage URI | drive_URI} \ dataset.table OR [3] bq mk \ --external_table_definition=schema@source_format = {Cloud Storage URI | drive_URI} \ dataset.table Nota: BigQuery consente di creare una tabella permanente collegata all'origine dati utilizzando un file di definizione della tabella [1], un file di schema JSON [2] o una definizione di schema incorporato [3]. La gestione temporanea dei file da leggere e la specifica delle opzioni di tipo di formato non sono supportate in BigQuery.
CREATE [OR REPLACE] EXTERNAL TABLE [IF EXISTS] <table_name> ((<col_name> <col_type> AS <expr> ) [ , ... ] ) [PARTITION BY (<identifier>, ...)] LOCATION = externalStage [REFRESH_ON_CREATE = {TRUE|FALSE}] [AUTO_REFRESH = {TRUE|FALSE}] [PATTERN = '<regex_pattern>'] FILE_FORMAT = ({FORMAT_NAME = '<file_format_name>' | TYPE = { CSV | JSON | AVRO | ORC | PARQUET} [ formatTypeOptions]}) [COPY GRANTS] [COMMENT = '<string_literal>']	bq mk \ --external_table_definition=definition_file \ dataset.table Nota: BigQuery attualmente non supporta nessuna delle opzioni dei parametri facoltative fornite da Snowflake per la creazione di tabelle esterne. Per il partizionamento, BigQuery supporta l'utilizzo della pseudocolonna _FILE_NAME per creare tabelle/viste partizionate sulle tabelle esterne. Per ulteriori informazioni, vedi Esegui una query sulla pseudocolonna _FILE_NAME.

Inoltre, BigQuery supporta anche la query sui dati partizionati esternamente in formati AVRO, PARQUET, ORC, JSON e CSV archiviati in Google Cloud Storage utilizzando un layout di partizione Hive predefinito.

CREATE VIEW dichiarazione

La tabella seguente mostra gli equivalenti tra Snowflake e BigQuery per l'istruzione CREATE VIEW.

Snowflake	BigQuery
CREATE VIEW view_name AS SELECT ...	CREATE VIEW view_name AS SELECT ...
CREATE OR REPLACE VIEW view_name AS SELECT ...	CREATE OR REPLACE VIEW view_name AS SELECT ...
CREATE VIEW view_name (column_name, ...) AS SELECT ...	CREATE VIEW view_name AS SELECT ...
Non supportata	CREATE VIEW IF NOT EXISTS view_name OPTIONS(view_option_list) AS SELECT ...
CREATE VIEW view_name AS SELECT ... WITH NO SCHEMA BINDING	In BigQuery, per creare una vista, tutti gli oggetti di riferimento devono già esistere. BigQuery consente di eseguire query sulle origini dati esterne.

CREATE SEQUENCE dichiarazione

Le sequenze non vengono utilizzate in BigQuery. Per farlo, puoi utilizzare in batch. Per ulteriori informazioni sulle chiavi surrogate e sulle dimensioni con variazioni lente (SCD), consulta le seguenti guide:

• Chiavi surrogate BigQuery
• BigQuery e chiavi surrogate: un approccio pratico

INSERT INTO dataset.table SELECT *, ROW_NUMBER() OVER () AS id FROM dataset.table

DDL caricamento e unload dei dati

Snowflake supporta il caricamento e l'unload dei dati tramite fase, formato file e barra verticale i comandi di gestione dei dati. BigQuery fornisce anche più opzioni, come bq load, BigQuery Data Transfer Service, bq extract e così via. Questa sezione mette in evidenza le differenze nell'utilizzo di queste metodologie per il caricamento e lo scarico dei dati.

DDL di account e sessione

I concetti di account e sessione di Snowflake non sono supportati in BigQuery. BigQuery consente la gestione degli account tramite Cloud IAM a tutti i livelli. Inoltre, i modelli multi-istruzione transazioni non sono ancora supportate in BigQuery.

Funzioni definite dall'utente

Una funzione definita dall'utente consente di creare funzioni per le operazioni personalizzate. Queste funzioni accettare colonne di input, eseguire azioni e restituire il risultato di queste azioni come valore

Entrambi Fiocco di neve e BigQuery supportare le funzioni definite dall'utente utilizzando espressioni SQL e codice JavaScript.

Consulta le GoogleCloudPlatform/bigquery-utils/ GitHub di ASL per una libreria di funzioni definite dall'utente comuni di BigQuery.

Sintassi CREATE FUNCTION

La seguente tabella illustra le differenze nella sintassi di creazione delle funzioni UDF SQL tra Snowflake e BigQuery.

Snowflake	BigQuery
CREATE [ OR REPLACE ] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition s	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) AS sql_function_definition Nota: nella UDF SQL di BigQuery, il tipo di dati restituiti è facoltativo. BigQuery deducono il tipo di risultato della funzione dal corpo della funzione SQL quando una query chiama la funzione.
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS TABLE (col_name, col_data_type[,..]) AS sql_function_definition	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Nota:nella UDF SQL di BigQuery, la restituzione del tipo di tabella non è attualmente supportata, ma è inclusa nella roadmap del prodotto e sarà disponibile a breve. Tuttavia, BigQuery supporta la restituzione di ARRAY di tipo STRUCT.
CREATE [SECURE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Nota: Snowflake offre un'opzione sicura per limitare la definizione e i dettagli delle funzioni definite dall'utente solo agli utenti autorizzati (ovvero agli utenti a cui viene concesso il ruolo proprietario della vista).	CREATE FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Nota: la sicurezza della funzione non è un parametro configurabile in BigQuery. BigQuery supporta la creazione di ruoli e autorizzazioni IAM per limitare l'accesso ai dati sottostanti e alla definizione delle funzioni.
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type [ { CALLED ON NULL INPUT | { RETURNS NULL ON NULL INPUT | STRICT } } ] AS sql_function_definition	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Nota: il comportamento della funzione per gli input null viene gestito implicitamente in BigQuery e non deve essere specificato come opzione separata.
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type [VOLATILE | IMMUTABLE] AS sql_function_definition	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Nota:la volatilità della funzione non è un parametro configurabile in BigQuery. Tutta la volatilità delle funzioni UDF di BigQuery è equivalente alla volatilità IMMUTABLE di Snowflake (ovvero non esegue ricerche nel database o non utilizza in altro modo informazioni non direttamente presenti nell'elenco degli argomenti).
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS [' | $$] sql_function_definition [' | $$]	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Nota: utilizzare virgolette singole o una sequenza di caratteri come la citazione in dollari ($$) is not required or supported in BigQuery. BigQuery implicitly interprets the SQL expression.
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type [COMMENT = '<string_literal>'] AS sql_function_definition	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Note:Adding comments or descriptions in UDFs is currently not supported in BigQuery.
CREATE [OR REPLACE] FUNCTION function_name (x integer, y integer) RETURNS integer AS $$ SELECT x + y $$ Note: Snowflake does not support ANY TYPE for SQL UDFs. However, it supports using VARIANT data types.	CREATE [OR REPLACE] FUNCTION function_name (x ANY TYPE, y ANY TYPE) AS SELECT x + y Note: BigQuery supports using ANY TYPE as argument type. The function will accept an input of any type for this argument. For more information, see templated parameter in BigQuery.

BigQuery also supports the CREATE FUNCTION IF NOT EXISTSstatement which treats the query as successful and takes no action if a function with the same name already exists.

BigQuery's CREATE FUNCTIONstatement also supports creating TEMPORARY or TEMP functions, which do not have a Snowflake equivalent. See calling UDFs for details on executing a BigQuery persistent UDF.

DROP FUNCTION syntax

The following table addresses differences in DROP FUNCTION syntax between Snowflake and BigQuery.

Snowflake	BigQuery
DROP FUNCTION [IF EXISTS] function_name ([arg_data_type, ... ])	DROP FUNCTION [IF EXISTS] dataset_name.function_name Note: BigQuery does not require using the function's signature (argument data type) for deleting the function.

BigQuery requires that you specify the project_name if the function is not located in the current project.

Additional function commands

This section covers additional UDF commands supported by Snowflake that are not directly available in BigQuery.

ALTER FUNCTION syntax

Snowflake supports the following operations using ALTER FUNCTION syntax.

• Renaming a UDF
• Converting to (or reverting from) a secure UDF
• Adding, overwriting, removing a comment for a UDF

As configuring function security and adding function comments is not available in BigQuery, ALTER FUNCTION syntax is currently not supported. However, the CREATE FUNCTION statement can be used to create a UDF with the same function definition but a different name.

DESCRIBE FUNCTION syntax

Snowflake supports describing a UDF using DESC[RIBE] FUNCTION syntax. This is currently not supported in BigQuery. However, querying UDF metadata via INFORMATION SCHEMA will be available soon as part of the product roadmap.

SHOW USER FUNCTIONS syntax

In Snowflake, SHOW USER FUNCTIONS syntax can be used to list all UDFs for which users have access privileges. This is currently not supported in BigQuery. However, querying UDF metadata via INFORMATION SCHEMA will be available soon as part of the product roadmap.

Stored procedures

Snowflake stored procedures are written in JavaScript, which can execute SQL statements by calling a JavaScript API. In BigQuery, stored procedures are defined using a block of SQL statements.

CREATE PROCEDURE syntax

In Snowflake, a stored procedure is executed with a CALL command while in BigQuery, stored procedures are executed like any other BigQuery function.

The following table addresses differences in stored procedure creation syntax between Snowflake and BigQuery.

Snowflake	BigQuery
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type AS procedure_definition; Note: Snowflake requires that stored procedures return a single value. Hence, return data type is a required option.	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_mode arg_name arg_data_type[,..]]) BEGIN procedure_definition END; arg_mode: IN | OUT | INOUT Note: BigQuery doesn't support a return type for stored procedures. Also, it requires specifying argument mode for each argument passed.
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type AS $$ javascript_code $$;	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN statement_list END;
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type [{CALLED ON NULL INPUT | {RETURNS NULL ON NULL INPUT | STRICT}}] AS procedure_definition;	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN procedure_definition END; Nota: il comportamento della procedura per gli input null viene gestito implicitamente in BigQuery e non deve essere specificato come opzione separata.
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type [VOLATILE | IMMUTABLE] AS procedure_definition;	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN procedure_definition END; Nota: la volatilità della procedura non è un parametro configurabile in BigQuery. Equivale alla volatilità IMMUTABLE di Snowflake.
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type [COMMENT = '<string_literal>'] AS procedure_definition;	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN procedure_definition END; Nota:l'aggiunta di commenti o descrizioni nelle definizioni delle procedure non è attualmente supportata in BigQuery.
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type [EXECUTE AS { CALLER | OWNER }] AS procedure_definition; Nota: Snowflake supporta la specifica dell'autore o del chiamante della procedura per l'esecuzione	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN procedure_definition END; Nota: le stored procedure BigQuery vengono sempre eseguite come chiamante

BigQuery supporta anche l'istruzione CREATE PROCEDURE IF NOT EXISTS, che tratta la query come riuscita e non esegue alcuna azione se esiste già una funzione con lo stesso nome.

Sintassi DROP PROCEDURE

La seguente tabella illustra le differenze nella sintassi di DROP FUNCTION tra Snowflake e BigQuery.

Snowflake	BigQuery
DROP PROCEDURE [IF EXISTS] procedure_name ([arg_data_type, ... ])	DROP PROCEDURE [IF EXISTS] dataset_name.procedure_name Nota: BigQuery non richiede l'utilizzo della firma della procedura (tipo di dati dell'argomento) per l'eliminazione della procedura.

BigQuery richiede di specificare il nome del progetto se la procedura non si trova nel progetto corrente.

Comandi aggiuntivi della procedura

Snowflake fornisce comandi aggiuntivi come ALTER PROCEDURE, DESC[RIBE] PROCEDURE, e SHOW PROCEDURES per gestire le procedure memorizzate. Al momento non sono supportati in in BigQuery.

Istruzioni SQL per metadati e transazioni

Snowflake	BigQuery
BEGIN [ { WORK | TRANSACTION } ] [ NAME <name> ]; START_TRANSACTION [ name <name> ];	BigQuery utilizza sempre l'isolamento degli snapshot. Per maggiori dettagli, consulta la sezione Garanzia di coerenza in questo documento.
COMMIT;	Non utilizzato in BigQuery.
ROLLBACK;	Non utilizzato in BigQuery
SHOW LOCKS [ IN ACCOUNT ]; SHOW TRANSACTIONS [ IN ACCOUNT ]; Note: If the user has the ACCOUNTADMIN role, the user can see locks/transactions for all users in the account.	Non utilizzato in BigQuery.

Istruzioni SQL con più istruzioni e su più righe

Sia Snowflake sia BigQuery supportano le transazioni (sessioni) e quindi supportano le istruzioni separate da punti e virgola che vengono eseguite con coerenza insieme. Per ulteriori informazioni, consulta la sezione Transazioni con più istruzioni.

Colonne dei metadati per i file temporanei

Snowflake genera automaticamente metadati per i file in ambienti interni ed esterni fasi iniziali. Questi metadati possono essere sottoposti a query e caricati in una tabella insieme alle normali colonne di dati. È possibile utilizzare le seguenti colonne di metadati:

• METADATA$FILENAME
• METADATA$FILE_ROW_NUMBER

Garanzie di coerenza e isolamento delle transazioni

Sia Snowflake che BigQuery sono atomici, ovvero conformi ad ACID a livello di mutazione su molte righe.

Transazioni

A ogni transazione Snowflake viene assegnata un'ora di inizio unica (include millisecondi) impostato come ID transazione. Snowflake supporta solo il livello di isolamento READ COMMITTED. Tuttavia, un'istruzione può vedere le modifiche apportate da un'altra istruzione se entrambe le transazioni avvengono nella stessa transazione, anche se tali modifiche non impegnato. Le transazioni Snowflake acquisiscono i blocchi sulle risorse (tabelle) quando la risorsa viene modificata. Gli utenti possono regolare il tempo massimo di attesa di un'istruzione bloccata prima del timeout. Le istruzioni DML vengono committate automaticamente se il parametro AUTOCOMMIT è attivo.

BigQuery inoltre supporta le transazioni. BigQuery contribuisce a garantire il controllo della concorrenza ottimistico (chi esegue prima il commit vince) con l'isolamento degli snapshot, in cui una query legge gli ultimi dati sottoposti a commit prima dell'inizio della query. Questo approccio garantisce lo stesso livello di coerenza su base per riga, per mutazione e tra righe all'interno della stessa istruzione DML, evitando al contempo i deadlock. Nel caso di più aggiornamenti DML per la stessa tabella, BigQuery passa controllo pessimistico della contemporaneità. I job di caricamento possono essere eseguiti in modo completamente indipendente e aggiunti alle tabelle. Tuttavia, BigQuery non fornisce ancora un confine o una sessione di transazioni espliciti.

Esegui il rollback

Se la sessione di una transazione Snowflake viene terminata inaspettatamente prima del di cui viene eseguito il commit o il rollback, la transazione viene lasciata in un ambiente stato. L'utente deve eseguire SYSTEM$ABORT_TRANSACTION per abortire la transazione staccata, altrimenti Snowflake eseguirà il rollback della transazione staccata dopo quattro ore di inattività. Se si verifica un deadlock, Snowflake lo rileva e seleziona l'istruzione più recente da eseguire in modo da eseguire il rollback. Se l'istruzione DML in un modello di la transazione non va a buon fine, viene eseguito il rollback delle modifiche, ma la transazione rimane aperta fino a quando non viene eseguito il commit o il rollback. Le istruzioni DDL in Snowflake non possono essere con il rollback automatico.

BigQuery supporta ROLLBACK TRANSACTION. Non è presente una dichiarazione ABORT in BigQuery.

Limiti per i database

Controlla sempre la documentazione pubblica di BigQuery per consultare le quote e i limiti più recenti. Molte quote per gli utenti con volumi elevati possono essere aumentate contattando il team di assistenza Cloud.

Per impostazione predefinita, tutti gli account Snowflake hanno limiti flessibili impostati. I limiti flessibili vengono impostati durante la creazione dell'account e possono variare. È possibile aumentare molti limiti morbidi Snowflake tramite il team dedicato all'account Snowflake o tramite un ticket di assistenza.

La tabella seguente mostra un confronto tra Snowflake e BigQuery limiti del database.

Limite	Snowflake	BigQuery
Dimensioni del testo della query	1 MB	1 MB
Numero massimo di query in parallelo	Magazzino XS - 8 Magazzino S - 16 Magazzino M - 32 Magazzino L - 64 Magazzino XL - 128	100