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. Il data warehousing di Snowflake è progettato per funzionare con la sintassi SQL specifica di Snowflake. Gli scriptscritti per Snowflake potrebbero dover essere modificati prima di poterli utilizzare in BigQuery, poiché i dialetti SQL variano da un servizio all'altro. Utilizza la traduzione SQL batch per eseguire la migrazione collettiva degli script SQL o la traduzione SQL interattiva per tradurre le query ad hoc. Snowflake SQL è supportato da entrambi gli strumenti 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 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 scala facoltativamente specificate 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 che "NaN" è > X, dove X è qualsiasi valore FLOAT (diverso dal valore "NaN" stesso). Il tipo di dati FLOAT in BigQuery stabilisce che "NaN" è < 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 archiviato 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 di VARCHAR di Snowflake.
BINARY	BYTES
VARBINARY	BYTES
BOOLEAN	BOOL	A differenza del tipo di dati BOOL in Snowflake, che può accettare TRUE/FALSE/NULL, il tipo di dati BOOL in BigQuery può accettare solo TRUE/FALSE.
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 e corrisponde 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 di 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 tipi VARIANT, mentre il tipo ARRAY in BigQuery può supportare tutti i tipi di dati, ad eccezione di un array stesso.

BigQuery dispone anche dei seguenti tipi di dati che non hanno un diretto analogo di Snowflake:

• DATETIME
• GEOGRAPHY

Sintassi delle query e operatori di query

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

SELECT dichiarazione

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

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 di Snowflake non fanno distinzione tra maiuscole e minuscole. Per mantenere la maiuscola, racchiudi gli alias e gli identificatori tra virgolette doppie (").

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 alle tabelle sono supportati 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 ha un'alternativa diretta a PRIMA di Snowflake che utilizza un ID comando. 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 in fase di staging.
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 che utilizzano FOR SYSTEM_TIME AS OF
• Percorsi dei campi o qualsiasi percorso che risolve in un campo all'interno di un tipo di dati (ovvero 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

Sia Snowflake che 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 tabella seguente contiene un elenco di differenze minori.

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'unione non laterale, l'output di un'unione laterale include solo le righe generate dalla visualizzazione in linea. Le righe sul lato sinistro non devono essere unite al lato destro perché sono già state prese in considerazione e passate alla 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

Una clausola WITH di BigQuery contiene una o più sottoquery denominate che vengono eseguite ogni volta che un'istruzione SELECT successiva fa riferimento a queste. Le clausole WITH di Snowflake si comportano come in BigQuery, ad eccezione del fatto 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, GROUP BY ALL, GROUP BY ROLLUP, GROUP BY GROUPING SETS, e GROUP BY CUBE.

Snowflake HAVING e BigQuery HAVING sono sinonimi. 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 insiemi di raggruppamento nello stesso blocco di query		SELECT col1 as one, col2 as two FROM table GROUP BY GROUPING SETS (one, 2)
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		SELECT col1 as one, col2 as two FROM table GROUP BY CUBE (one, 2)

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, i valori NULL sono classificati per ultimi per impostazione predefinita (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 di 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 clausola QUALIFY in Snowflake consente di filtrare i risultati per le funzioni finestra in modo simile a quanto avviene con HAVING e 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 di Snowflake con una funzione di analisi come ROW_NUMBER(), COUNT() e con OVER PARTITION BY è espressa in BigQuery come clausola WHERE in una sottoquery che contiene il valore di analisi. Utilizzo di ROW_NUMBER(): 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 le funzioni aggregate, aggregate analitiche e aggregate approssimative comuni di Snowflake e i relativi equivalenti di BigQuery.

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 Window
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 memorizzare lo stato intermedio durante la previsione di valori approssimativi.
APPROX_PERCENTILE_ESTIMATE(state, percentile)	BigQuery non supporta la possibilità di memorizzare lo stato intermedio durante la previsione di valori approssimativi.
APPROX_TOP_K(expression, [number [counters]] Nota: se non viene specificato alcun parametro numerico, il valore predefinito è 1. I contatori devono essere notevolmente più grandi del numero.	APPROX_TOP_COUNT(expression, number) Nota: BigQuery non supporta APPROX_TOP_COUNT con le funzioni Window.
APPROX_TOP_K_ACCUMULATE(expression, counters)	BigQuery non supporta la possibilità di memorizzare lo stato intermedio durante la previsione di valori approssimativi.
APPROX_TOP_K_COMBINE(state, [counters])	BigQuery non supporta la possibilità di memorizzare lo stato intermedio durante la previsione di 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 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. 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: AVG di BigQuery non esegue il trasferimento automatico dei 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 esegue il casting implicito delle colonne di caratteri/testo al valore INTEGER più vicino.
BOOLAND_AGG(expression) [OVER ...] Nota: Snowflake consente di trattare i valori numerici, decimali e in virgola mobile come TRUE se non sono pari a zero.	LOGICAL_AND(expression) [OVER ...]
BOOLOR_AGG(expression) [OVER ...] Nota: Snowflake consente di trattare i valori numerici, decimali e in virgola mobile come TRUE se non sono 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 comando (esempio booleano fornito): 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 ...]	SELECT BIT_XOR( FARM_FINGERPRINT( TO_JSON_STRING(t))) [OVER] FROM t
SELECT HLL([DISTINCT] expression1, [,expression2]) [OVER ...] Nota: Snowflake non ti 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 di 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 ...]	Ti consigliamo di utilizzare TO_JSON_STRING per convertire un valore in una stringa formattata in 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 eseguire il casting di VARCHAR in valori a 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 le funzioni di espressione a bit comuni di Snowflake e i relativi equivalenti di BigQuery.

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

Snowflake	BigQuery
BITAND(expression1, expression2)	BIT_AND(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 le espressioni condizionali comuni di Snowflake e i relativi equivalenti di 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 in virgola mobile come TRUE se non sono pari a zero.	NOT expression
BOOLOR Nota: Snowflake consente di trattare i valori numerici, decimali e in virgola mobile come TRUE se non sono 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 in virgola mobile come TRUE se non sono 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 condizionali. Questo può essere utilizzato per riprodurre 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 le funzioni di contesto Snowflake comuni e i relativi 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 Viene restituita 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 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 funzione può essere chiamata senza "()".	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 funzione può essere chiamata senza "()". 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 in base al tipo di job, al 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 in base al tipo di job, al 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 e BigQuery potrebbero restituire tipi di dati diversi.

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: il casting STRING predefinito 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: in caso contrario, 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 tipi di dati STRING sono disponibili qui. BigQuery non ha un'alternativa al tipo di dati VARIANT.	CAST(expression AS TIME) Nota: BigQuery non ha 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/escludendo 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 Snowflake e i relativi equivalenti 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 le funzioni UDF permanenti per creare un equivalente di 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 le funzioni di data e ora comuni di Snowflake e i relativi equivalenti di BigQuery. Le funzioni di BigQuery per i dati e il tempo includono le funzioni Data, le funzioni Data e ora, le funzioni Ora e le funzioni 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 parti ISO del giorno della settimana, nanosecondo ed epoche in secondi/millisecondi/microsecondi/nanosecondi. BigQuery no. Consulta l'elenco completo dei tipi di componenti 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 componenti 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 componenti 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.
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 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(<giorno della settimana>) 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. BigQuery no. Consulta l'elenco completo dei tipi di componenti 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 componenti 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 la stringa dow. 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 parti 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 componenti 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

Funzioni di tabelle e dello schema di informazioni

BigQuery non supporta concettualmente molte delle funzioni di schema e tabella 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 schemi di informazioni e funzioni di tabella associati a BigQuery e Snowflake.

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 e tabella di informazioni, 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: FLOOR di BigQuery non supporta la possibilità di indicare la precisione o la scala. ROUND non consente di specificare l'arrotondamento per eccesso. TRUNC ha lo stesso significato per i numeri positivi, ma non per quelli 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; non è supportato il valore uguale.

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 per i dati semistrutturati

Snowflake	BigQuery
ARRAY_APPEND	Funzione definita dall'utente personalizzata
ARRAY_CAT	ARRAY_CONCAT
ARRAY_COMPACT	Funzione definita dall'utente personalizzata
ARRAY_CONSTRUCT	[ ]
ARRAY_CONSTRUCT_COMPACT	Funzione definita dall'utente personalizzata
ARRAY_CONTAINS	Funzione definita dall'utente personalizzata
ARRAY_INSERT	Funzione definita dall'utente personalizzata
ARRAY_INTERSECTION	Funzione definita dall'utente personalizzata
ARRAY_POSITION	Funzione definita dall'utente personalizzata
ARRAY_PREPEND	Funzione definita dall'utente personalizzata
ARRAY_SIZE	ARRAY_LENGTH
ARRAY_SLICE	Funzione definita dall'utente personalizzata
ARRAY_TO_STRING	ARRAY_TO_STRING
ARRAYS_OVERLAP	Funzione definita dall'utente personalizzata
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 definita dall'utente personalizzata
CHECK_XML	Funzione definita dall'utente personalizzata
FLATTEN	UNNEST
GET	Funzione definita dall'utente personalizzata
GET_IGNORE_CASE	Funzione definita dall'utente personalizzata
GET_PATH , :	Funzione definita dall'utente personalizzata
IS_<object_type>	Funzione definita dall'utente personalizzata
IS_ARRAY	Funzione definita dall'utente personalizzata
IS_BINARY	Funzione definita dall'utente personalizzata
IS_BOOLEAN	Funzione definita dall'utente personalizzata
IS_CHAR , IS_VARCHAR	Funzione definita dall'utente personalizzata
IS_DATE , IS_DATE_VALUE	Funzione definita dall'utente personalizzata
IS_DECIMAL	Funzione definita dall'utente personalizzata
IS_DOUBLE , IS_REAL	Funzione definita dall'utente personalizzata
IS_INTEGER	Funzione definita dall'utente personalizzata
IS_OBJECT	Funzione definita dall'utente personalizzata
IS_TIME	Funzione definita dall'utente personalizzata
IS_TIMESTAMP_*	Funzione definita dall'utente personalizzata
OBJECT_CONSTRUCT	Funzione definita dall'utente personalizzata
OBJECT_DELETE	Funzione definita dall'utente personalizzata
OBJECT_INSERT	Funzione definita dall'utente personalizzata
PARSE_JSON	JSON_EXTRACT
PARSE_XML	Funzione definita dall'utente personalizzata
STRIP_NULL_VALUE	Funzione definita dall'utente personalizzata
STRTOK_TO_ARRAY	SPLIT
TRY_PARSE_JSON	Funzione definita dall'utente personalizzata
TYPEOF	Funzione definita dall'utente personalizzata
XMLGET	Funzione definita dall'utente 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 definita dall'utente personalizzata
COLLATION	Funzione definita dall'utente personalizzata
COMPRESS	Funzione definita dall'utente personalizzata
CONCAT(string1, string2)	CONCAT(string1, string2) Nota: CONCAT(...) di BigQuery supporta la concatenazione di un numero qualsiasi di stringhe.
CONTAINS	Funzione definita dall'utente personalizzata
DECOMPRESS_BINARY	Funzione definita dall'utente personalizzata
DECOMPRESS_STRING	Funzione definita dall'utente personalizzata
EDITDISTANCE	EDIT_DISTANCE
ENDSWITH	Funzione definita dall'utente personalizzata
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 definita dall'utente personalizzata
ILIKE ANY	Funzione definita dall'utente personalizzata
INITCAP	INITCAP
INSERT	Funzione definita dall'utente personalizzata
LEFT	Funzione definita dall'utente
LENGTH	LENGTH(expression)
LIKE	LIKE
LIKE ALL	Funzione definita dall'utente personalizzata
LIKE ANY	Funzione definita dall'utente personalizzata
LOWER	LOWER(string)
LPAD	LPAD(string1, length[, string2])
LTRIM	LTRIM(string1, trim_chars)
MD5,MD5_HEX	MD5(string)
MD5_BINARY	Funzione definita dall'utente personalizzata
OCTET_LENGTH	Funzione definita dall'utente personalizzata
PARSE_IP	Funzione definita dall'utente personalizzata
PARSE_URL	Funzione definita dall'utente 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 definita dall'utente personalizzata
SHA1,SHA1_HEX	SHA1(string)
SHA1_BINARY	Funzione definita dall'utente personalizzata
SHA2,SHA2_HEX	Funzione definita dall'utente personalizzata
SHA2_BINARY	Funzione definita dall'utente personalizzata
SOUNDEX	Funzione definita dall'utente personalizzata
SPACE	Funzione definita dall'utente personalizzata
SPLIT	SPLIT
SPLIT_PART	Funzione definita dall'utente personalizzata
SPLIT_TO_TABLE	Funzione definita dall'utente personalizzata
STARTSWITH	Funzione definita dall'utente personalizzata
STRTOK	SPLIT(instring, delimiter)[ORDINAL(tokennum)] Nota: l'intero parametro di stringa del delimitatore viene utilizzato come un singolo delimitatore. Il delimitatore predefinito è una virgola.
STRTOK_SPLIT_TO_TABLE	Funzione definita dall'utente dall'utente
SUBSTR,SUBSTRING	SUBSTR
TRANSLATE	Funzione definita dall'utente personalizzata
TRIM	TRIM
TRY_BASE64_DECODE_BINARY	Funzione definita dall'utente personalizzata
TRY_BASE64_DECODE_STRING	SUBSTR(string, 0, integer)
TRY_HEX_DECODE_BINARY	SUBSTR(string, -integer)
TRY_HEX_DECODE_STRING	LENGTH(expression)
UNICODE	Funzione definita dall'utente personalizzata
UPPER	UPPER

Funzioni di stringa (espressioni regolari)

Snowflake	BigQuery
REGEXP	IF(REGEXP_CONTAINS,1,0)=1
REGEXP_COUNT	ARRAY_LENGTH( REGEXP_EXTRACT_ALL( source_string, pattern ) ) Se è specificato position: ARRAY_LENGTH( REGEXP_EXTRACT_ALL( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern ) ) Nota: BigQuery fornisce il supporto delle 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 è specificato replace_string: 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 è specificato position: 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 delle 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 definita dall'utente personalizzata
SYSTEM$ABORT_TRANSACTION	Funzione definita dall'utente personalizzata
SYSTEM$CANCEL_ALL_QUERIES	Funzione definita dall'utente personalizzata
SYSTEM$CANCEL_QUERY	Funzione definita dall'utente personalizzata
SYSTEM$CLUSTERING_DEPTH	Funzione definita dall'utente personalizzata
SYSTEM$CLUSTERING_INFORMATION	Funzione definita dall'utente personalizzata
SYSTEM$CLUSTERING_RATIO — Deprecated	Funzione definita dall'utente personalizzata
SYSTEM$CURRENT_USER_TASK_NAME	Funzione definita dall'utente personalizzata
SYSTEM$DATABASE_REFRESH_HISTORY	Funzione definita dall'utente personalizzata
SYSTEM$DATABASE_REFRESH_PROGRESS , SYSTEM$DATABASE_REFRESH_PROGRESS_BY_JOB	Funzione definita dall'utente personalizzata
SYSTEM$GET_AWS_SNS_IAM_POLICY	Funzione definita dall'utente personalizzata
SYSTEM$GET_PREDECESSOR_RETURN_VALUE	Funzione definita dall'utente personalizzata
SYSTEM$LAST_CHANGE_COMMIT_TIME	Funzione definita dall'utente personalizzata
SYSTEM$PIPE_FORCE_RESUME	Funzione definita dall'utente personalizzata
SYSTEM$PIPE_STATUS	Funzione definita dall'utente personalizzata
SYSTEM$SET_RETURN_VALUE	Funzione definita dall'utente personalizzata
SYSTEM$SHOW_OAUTH_CLIENT_SECRETS	Funzione definita dall'utente personalizzata
SYSTEM$STREAM_GET_TABLE_TIMESTAMP	Funzione definita dall'utente personalizzata
SYSTEM$STREAM_HAS_DATA	Funzione definita dall'utente personalizzata
SYSTEM$TASK_DEPENDENTS_ENABLE	Funzione definita dall'utente personalizzata
SYSTEM$TYPEOF	Funzione definita dall'utente personalizzata
SYSTEM$USER_TASK_CANCEL_ONGOING_EXECUTIONS	Funzione definita dall'utente personalizzata
SYSTEM$WAIT	Funzione definita dall'utente personalizzata
SYSTEM$WHITELIST	Funzione definita dall'utente personalizzata
SYSTEM$WHITELIST_PRIVATELINK	Funzione definita dall'utente dall'utente

Funzioni tabella

Snowflake		BigQuery
GENERATOR		Funzione definita dall'utente personalizzata
GET_OBJECT_REFERENCES		Funzione definita dall'utente personalizzata
RESULT_SCAN		Funzione definita dall'utente personalizzata
VALIDATE		Funzione definita dall'utente 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 definita dall'utente personalizzata
CONDITIONAL_TRUE_EVENT		Funzione definita dall'utente personalizzata
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 definita dall'utente personalizzata
ROW_NUMBER		ROW_NUMBER
WIDTH_BUCKET		Funzione definita dall'utente personalizzata

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 gli operatori aritmetici di Snowflake e i relativi equivalenti di 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 su scala e precisione di Snowflake durante l'esecuzione di operazioni aritmetiche, consulta la documentazione di Snowflake.

Operatori di confronto

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

Operatori logici/booleani

Gli operatori logici/booleani di Snowflake e gli operatori logici/booleani di BigQuery sono gli stessi.

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 TUTTI/OGNI 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 sugli insiemi. 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. Utilizza invece 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 INSERTsmultitabelle condizionali e non condizionali.

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 una fase interna denominata, a una fase 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 una delle varie opzioni e degli strumenti non SQL per caricare i dati nelle tabelle BigQuery. Puoi anche utilizzare gli accumuli della 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 tabella seguente 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.

Estratti conto DELETE e TRUNCATE TABLE

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 di caricamento dei file esterni e i metadati di caricamento.

In BigQuery, l'istruzione DELETE deve avere una clausola WHERE. Per maggiori informazioni su DELETE in BigQuery, consulta gli esempi di DELETE di BigQuery nella documentazione 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 clausola WHERE .

MERGE dichiarazione

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

Le tabelle BigQuery sono limitate a 1000 istruzioni DML al giorno, pertanto è consigliabile consolidare in modo ottimale le istruzioni INSERT, UPDATE ed DELETE in un'unica istruzione MERGE, come mostrato nella tabella seguente:

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.

Estratti conto GET e LIST

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

L'istruzione LIST (LS) restituisce un elenco di file che sono stati sottoposti a staging (ovvero caricati da un file system locale o scaricati da una tabella) in una delle seguenti fasi di Snowflake:

• Fase interna denominata
• Fase esterna denominata
• 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.

PUT e REMOVE estratti conto

L'istruzione PUT carica (ovvero esegue l'archiviazione in un'area intermedia) i file di dati da una directory/cartella locale su un computer client in 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 di database, schema e condivisione

La maggior parte della terminologia di Snowflake corrisponde a quella di BigQuery, tranne che il database Snowflake è simile al set di dati BigQuery. Consulta la mappatura dettagliata della terminologia di Snowflake a BigQuery.

CREATE DATABASE dichiarazione

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 set di dati temporanei 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>	Il viaggio nel tempo a livello di set di dati non è supportato in BigQuery. Tuttavia, il viaggio nel tempo per i risultati di tabelle e query è supportato.
CREATE DATABASE <name> DEFAULT_DDL_COLLATION = '<collation_specification>'	La Collazione in DDL non è supportata 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 dei set di dati utilizzando 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 hanno un analogo diretto in Snowflake:

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

ALTER DATABASE dichiarazione

Questa sezione utilizza 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 è supportata la copia dei set di dati.
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 è rimuovere 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 il comando UNDROP DATASET che ripristina la versione più recente di un set di dati eliminato. Al momento, questa funzionalità non è supportata in BigQuery a livello di 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 è più necessario specificare i nomi completi degli oggetti nei comandi SQL. BigQuery non fornisce alcuna alternativa al comando USE DATABASE di Snowflake.

SHOW DATABASE dichiarazione

In questa sezione verrà utilizzato il comando CLI BigQuery corrispondente al comando Snowflake per risolvere la differenza nell'istruzione SHOW.

Snowflake	BigQuery
SHOW DATABASES Nota: Snowflake fornisce un'unica opzione per elencare e mostrare i dettagli di tutti i database, inclusi quelli eliminati che rientrano 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. BigQuery fornisce anche ulteriori dettagli sui set di dati tramite lo schema di 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 dei 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 underscore)
• 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 set di dati anonimi dai risultati
• bq show --format=pretty: restituisce risultati di base dettagliati formattati per tutti i set di dati

Gestione di SCHEMA

Snowflake fornisce più comandi di gestione dello schema simili ai comandi di gestione del 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 utilizzare il rilevamento automatico dello schema per i 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 creazione e gestione della condivisione non è supportato in BigQuery.

DDL di tabelle, viste e sequenze

CREATE TABLE dichiarazione

La maggior parte delle istruzioni CREATE TABLE di Snowflake è compatibile con BigQuery, tranne i seguenti elementi di sintassi, che non vengono utilizzati in 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 ) dove table_constraints sono: [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 scoprire come 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 e il ripristino da 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(elenco_opzioni_tabella)

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

ALTER TABLE dichiarazione

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 della concatenazione 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 fornisce opzioni di clustering, colonne e vincoli per modificare le tabelle non supportate da BigQuery.

Estratti conto DROP TABLE e UNDROP TABLE

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 la tabella con quel timestamp in una nuova tabella. La nuova tabella deve avere un nome diverso dalla tabella eliminata.

CREATE EXTERNAL TABLE dichiarazione

BigQuery consente di creare sia tabelle esterne permanenti che temporanee sia di eseguire query sui dati direttamente da:

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

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

Questa sezione utilizzerà il comando della CLI BigQuery corrispondente al 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 la gestione temporanea dei file contenenti i dati da leggere e di specificare le opzioni di tipo di formato per le tabelle esterne. I tipi di formato Snowflake (CSV, JSON, AVRO, PARQUET, ORC) sono tutti supportati da BigQuery, ad eccezione del tipo XML.	[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 in linea [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: al momento BigQuery non supporta nessuna delle opzioni di parametro 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, consulta Eseguire 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 visualizzazione tutti gli oggetti a cui viene fatto riferimento devono già esistere. BigQuery consente di eseguire query sulle origini dati esterne.

CREATE SEQUENCE dichiarazione

Le sequenze non vengono utilizzate in BigQuery, ma è possibile ottenere lo stesso risultato con il seguente metodo 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 per il caricamento e lo scarico dei dati

Snowflake supporta il caricamento e lo scarico dei dati tramite comandi di gestione di stage, formato file e pipeline. 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, le transazioni con più istruzioni non sono ancora supportate in BigQuery.

Funzioni definite dall'utente

Una funzione definita dall'utente consente di creare funzioni per operazioni personalizzate. Queste funzioni accettano colonne di input, eseguono azioni e restituiscono il risultato di queste azioni come valore

Sia Snowflake che BigQuery supportano le funzioni definite dall'utente che utilizzano espressioni SQL e codice JavaScript.

Consulta il repository GitHub GoogleCloudPlatform/bigquery-utils/ per una libreria di funzioni UDF di BigQuery comuni.

Sintassi di 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: nelle funzioni UDF SQL di BigQuery, il tipo di dati restituito è 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:in BigQuery UDF SQL, il tipo di tabella restituito non è attualmente supportato, ma è 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 a quelli a cui è stato assegnato 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 delle funzioni 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à delle funzioni 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: l'utilizzo di virgolette singole o di una sequenza di caratteri come le virgolette monetarie ($$) 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. È equivalente 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 di 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 di procedura aggiuntivi

Snowflake fornisce comandi aggiuntivi come ALTER PROCEDURE, DESC[RIBE] PROCEDURE, e SHOW PROCEDURES per gestire le procedure memorizzate. Al momento non sono supportati 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 di metadati per i file sottoposti a staging

Snowflake genera automaticamente i metadati per i file nelle fasi interne ed esterne. 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 una data e ora di inizio univoca (inclusi i millisecondi) che viene impostata 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 si trovano nella stessa transazione, anche se queste modifiche non sono ancora state committate. 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 supporta inoltre 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. In caso di più aggiornamenti DML nella stessa tabella, BigQuery passa al controllo della concorrenza pessimistico. 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 interrotta in modo imprevisto prima che la transazione venga confermata o annullata, la transazione viene lasciata in uno stato scollegato. 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 una transazione aperta esplicitamente non va a buon fine, le modifiche vengono annullate, ma la transazione viene mantenuta aperta fino al commit o all'annullamento. Le istruzioni DDL in Snowflake non possono essere rollback poiché sono sottoposte a commit automatico.

BigQuery supporta l'istruzione ROLLBACK TRANSACTION. In BigQuery non esiste l'istruzione ABORT.

Limiti per i database

Controlla sempre la documentazione pubblica di BigQuery per consultare le quote e i limiti più recenti. Molte quote per 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. Molti limiti soft di Snowflake possono essere aumentati tramite il team degli account Snowflake o un ticket di assistenza.

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

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