Guida alla traduzione SQL Snowflake

Questo documento descrive in dettaglio le somiglianze e le differenze nella sintassi SQL tra Snowflake e BigQuery per accelerare la pianificazione e l'esecuzione dello spostamento di EDW (Enterprise Data Warehouse) in BigQuery. Il data warehouse di Snowflake è progettato per funzionare con la sintassi SQL specifica di Snowflake. Gli script scritti per Snowflake potrebbero dover essere modificati prima di poter essere utilizzati in BigQuery, poiché i dialetti SQL variano tra i servizi. Utilizza la traduzione SQL in gruppo per eseguire la migrazione collettiva degli script SQL oppure la traduzione SQL interattiva per tradurre le query ad hoc. SQL Snowflake è 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 in BigQuery le stesse funzionalità disponibili in Snowflake con mezzi alternativi, 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 precisità e scalabilità specificate facoltativamente entro determinati limiti.
INT/INTEGER	BIGNUMERIC	INT/INTEGER e tutti gli altri tipi di dati simili a INT, ad esempio BIGINT, TINYINT, SMALLINT, BYTEINT rappresentano un alias per il tipo di dati NUMBER, dove non è possibile specificare precisione e scala ed è sempre NUMBER(38, 0)
BIGINT	BIGNUMERIC
SMALLINT	BIGNUMERIC
TINYINT	BIGNUMERIC
BYTEINT	BIGNUMERIC
FLOAT/ FLOAT4/ FLOAT8	FLOAT64	Il tipo di dati FLOAT in Snowflake stabilisce "NaN" come > X, dove X è qualsiasi valore FLOAT (tranne "NaN" stesso). Il tipo di dati FLOAT in BigQuery stabilisce "NaN" come < X, dove X è qualsiasi valore FLOAT (tranne "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. È memorizzato correttamente come DOUBLE.
VARCHAR	STRING	Il tipo di dati VARCHAR in Snowflake ha una lunghezza massima di 16 MB (non compresso). Se la lunghezza non è specificata, l'impostazione predefinita è la lunghezza massima. Il tipo di dati STRING in BigQuery viene archiviato come Unicode con codifica UTF-8 a 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	Il tipo di dati BOOL in BigQuery può accettare solo TRUE/FALSE, a differenza del tipo di dati BOOL in Snowflake, che può accettare TRUE/FALSE/NULL.
DATE	DATE	Il tipo DATE in Snowflake accetta i formati di data più comuni, a differenza del tipo DATE in BigQuery, che accetta solo date nel formato "AAAA-[M]M-[G]G".
TIME	TIME	Il tipo TIME in Snowflake supporta da 0 a 9 nanosecondi di precisione, mentre il tipo TIME in BigQuery supporta da 0 a 6 nanosecondi di precisione.
TIMESTAMP	DATETIME	TIMESTAMP è un alias configurabile dall'utente che per impostazione predefinita è TIMESTAMP_NTZ e viene mappato a DATETIME in BigQuery.
TIMESTAMP_LTZ	TIMESTAMP
TIMESTAMP_NTZ/DATETIME	DATETIME
TIMESTAMP_TZ	TIMESTAMP
OBJECT	JSON	Il tipo OBJECT in Snowflake non supporta valori di tipo esplicito. I valori sono del tipo VARIANT.
VARIANT	JSON	Il tipo OBJECT in Snowflake non supporta valori di tipo esplicito. I valori sono del tipo VARIANT.
ARRAY	ARRAY<JSON>	Il tipo ARRAY in Snowflake può supportare solo i tipi VARIANT, mentre il tipo ARRAY in BigQuery può supportare tutti i tipi di dati ad eccezione di un array stesso.

BigQuery include inoltre i seguenti tipi di dati che non hanno un analogo analogo di Snowflake diretto:

• DATETIME
• GEOGRAPHY

Sintassi e operatori di query

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

Istruzione SELECT

La maggior parte delle istruzioni SELECT Snowflake è compatibile con BigQuery. La seguente tabella contiene un elenco di differenze di minore entità.

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

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

BigQuery supporta le seguenti espressioni nelle istruzioni SELECT, che non hanno un equivalente Snowflake:

• EXCEPT
• REPLACE

Clausola FROM

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

La tabella seguente contiene un elenco delle 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 all'istanza PRIMA di Snowflake a utilizzare un ID istruzione. Il valore del timestamp non può precedere il timestamp attuale di sette giorni.
@[namespace]<stage_name>[/path]		BigQuery non supporta il concetto di file temporanei.
SELECT* FROM table START WITH predicate CONNECT BY [PRIOR] col1 = [PRIOR] col2 [, ...] ...		BigQuery non offre un'alternativa diretta a CONNECT BY di Snowflake.

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

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

BigQuery supporta anche riferimenti tabella aggiuntivi:

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

Clausola WHERE

La frase di Snowflake WHERE e la clausola di BigQuery WHERE sono identiche, ad eccezione di 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 JOIN

JOIN tipo

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 "cross join con virgola" implicito

Sia Snowflake che BigQuery supportano la clausola ONandUSING.

La tabella seguente contiene un elenco delle 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 CROSS JOIN o di una delle tabelle unite non è un campo all'interno di un tipo di dati o un array.
SELECT ... FROM table1 AS t1, LATERAL ( SELECT* FROM table2 AS t2 WHERE t1.col = t2.col ) Nota: a differenza dell'output di un join non laterale, l'output di un join laterale include solo le righe generate dalla visualizzazione in linea. Le righe sul lato sinistro non devono essere unite al lato destro perché le righe sul lato sinistro sono già state già prese in considerazione perché erano passate nella visualizzazione in linea.		SELECT ... FROM table1 as t1 LEFT JOIN table2 as t2 ON t1.col = t2.col Nota: BigQuery non supporta un'alternativa diretta per i LATERAL JOIN.

Clausola WITH

Una clausola WITH di BigQuery contiene una o più sottoquery denominate che vengono eseguite ogni volta che viene fatto riferimento a un'istruzione SELECT successiva. Le clausole di Snowflake WITH si comportano come 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 e GROUP BY ROLLUP.

Snowflake HAVING e BigQuery HAVING sono sinonimo. Tieni presente che il valore HAVING si trova dopo il giorno GROUP BY e l'aggregazione e prima del giorno ORDER BY.

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

Clausola ORDER BY

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

Snowflake		BigQuery
In Snowflake, gli elementi NULL sono classificati all'ultimo per impostazione predefinita (ordine crescente).		In BigQuery, i NULLS sono classificati al primo posto per impostazione predefinita (ordine crescente).
Puoi specificare se i valori NULL devono essere ordinati per primo o per ultimo 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'istruzione o una sottoquery. LIMIT (sintassi Postgres) e FETCH (sintassi ANSI) producono lo stesso risultato.

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

Snowflake		BigQuery
SELECT col1, col2 FROM table ORDER BY col1 LIMIT count OFFSET start SELECT ... FROM ... ORDER BY ... OFFSET start {[ROW | ROWS]} FETCH {[FIRST | NEXT]} count {[ROW | ROWS]} [ONLY] Nota: i valori NULL, stringa vuota ('') e $$$$ sono accettati e vengono trattati come "illimitati". L'utilizzo principale riguarda 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 LIMIT count. Assicurati di impostare il valore count INT64 sul numero minimo di righe ordinate necessarie per ottenere le migliori prestazioni. Ordinare inutilmente tutte le righe di risultati comporterà un peggioramento delle prestazioni di esecuzione della query.

Clausola QUALIFY

La frase QUALIFY in Snowflake ti consente di filtrare i risultati per le funzioni di finestra in modo simile a ciò che fa HAVING con le funzioni aggregate e le clausole GROUP BY.

Snowflake		BigQuery
SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1;		La clausola QUALIFY Snowflake con una funzione di analisi come ROW_NUMBER(), COUNT() e con OVER PARTITION BY è espressa in BigQuery come una clausola WHERE su una sottoquery contenente il valore di Analytics. Con ROW_NUMBER(): SELECT col1, col2 FROM ( SELECT col1, col2 ROW NUMBER() OVER (PARTITION BY col1 ORDER by col2) RN FROM table ) WHERE RN = 1; Utilizzo di 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 seguenti sezioni elencano le funzioni Snowflake e i relativi equivalenti BigQuery.

Funzioni di aggregazione

La seguente tabella mostra le mappature tra le funzioni di aggregazione comuni di Snowflake, di aggregazione e di aggregazione approssimativa con i relativi equivalenti 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 archiviare lo stato intermedio durante la previsione di valori approssimativi.
APPROX_PERCENTILE_COMBINE(state)	BigQuery non supporta la possibilità di archiviare lo stato intermedio durante la previsione di valori approssimativi.
APPROX_PERCENTILE_ESTIMATE(state, percentile)	BigQuery non supporta la possibilità di archiviare lo stato intermedio durante la previsione di valori approssimativi.
APPROX_TOP_K(expression, [number [counters]] Nota: se non viene specificato nessun parametro numerico, il valore predefinito è 1. I contatori devono essere molto più grandi del numero.	APPROX_TOP_COUNT(expression, number) Nota: BigQuery non supporta APPROX_TOP_COUNT con le funzioni Window.
APPROX_TOP_K_ACCUMULATE(expression, counters)	BigQuery non supporta la possibilità di archiviare lo stato intermedio durante la previsione di valori approssimativi.
APPROX_TOP_K_COMBINE(state, [counters])	BigQuery non supporta la possibilità di archiviare lo stato intermedio durante la previsione di valori approssimativi.
APPROX_TOP_K_ESTIMATE(state, [k])	BigQuery non supporta la possibilità di archiviare lo stato intermedio durante la previsione di valori approssimativi.
APPROXIMATE_JACCARD_INDEX([DISTINCT] expression)	Puoi utilizzare una funzione definita dall'utente 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 Jacquard 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 allo 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: il AVG di BigQuery non esegue la trasmissione automatica su STRING.
BITAND_AGG(expression) [OVER ...]	BIT_AND(expression) [OVER ...] Nota: BigQuery non trasmette implicitamente colonne di caratteri/testo al valore INTEGER più vicino.
BITOR_AGG(expression) [OVER ...]	BIT_OR(expression) [OVER ...] Nota: BigQuery non trasmette implicitamente colonne di caratteri/testo al INTEGER più vicino.
BITXOR_AGG([DISTINCT] expression) [OVER ...]	BIT_XOR([DISTINCT] expression) [OVER ...] Nota: BigQuery non trasmette implicitamente colonne di caratteri/testo al INTEGER più vicino.
BOOLAND_AGG(expression) [OVER ...] Nota: Snowflake consente di trattare 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 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 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 questo 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 ...]	SELEZIONA BIT_XOR( FARM_FINGERPRINT( TO_JSON_STRING(t))) [OVER] DA
SELECT HLL([DISTINCT] expression1, [,expression2]) [OVER ...] Nota: Snowflake non consente di specificare la precisione.	SELECT HLL_COUNT.EXTRACT(sketch) FROM ( SELECT HLL_COUNT.INIT(expression) AS sketch FROM table ) Nota: BigQuery non supporta HLL_COUNT… con Window Functions. Un utente non può includere più espressioni in una singola funzione HLL_COUNT....
HLL_ACCUMULATE([DISTINCT] expression) Nota: Snowflake non consente di specificare la precisione.	HLL_COUNT.INIT(espressione [, precisione])
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 di LIMIT direttamente in ARRAY_AGG.	PERCENTILE_CONT( value_expression, 0.5 [ {RESPECT | IGNORE} NULLI] ) OVER()
MAX(expression) [OVER ...] MIN(expression) [OVER ...]	MAX(expression) [OVER ...] MIN(expression) [OVER ...]
MINHASH(k, [DISTINCT] expressions)	Puoi utilizzare una funzione definita dall'utente personalizzata per implementare MINHASH con k funzioni hash diverse. Un altro approccio per ridurre la varianza in MINHASH è mantenere k dei valori minimi di una funzione hash: SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS MINHASH FROM t ORDER BY MINHASH LIMIT k
MINHASH_COMBINE([DISTINCT] state)	<codice<seleziona FROM ( SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS h FROM TA AS t ORDER BY h LIMIT k UNION SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS h FROM TB AS t ORDER BY h LIMIT k ) ORDER BY h LIMIT k
MODE(expr1) OVER ( [ PARTITION BY <expr2> ] )	SELECT expr1 FROM ( SELECT expr1, ROW_NUMBER() OVER ( PARTITION BY expr2 ORDER BY cnt DESC) rn FROM ( SELECT expr1, expr2, COUNTIF(expr1 IS NOT NULL) OVER (PARTITION BY expr2, expr1) cnt FROM t)) WHERE rn = 1
OBJECT_AGG(key, value) [OVER ...]	Puoi considerare l'utilizzo di TO_JSON_STRING per convertire un valore in una stringa in formato JSON.
PERCENTILE_CONT(percentile) WITHIN GROUP (ORDER BY value_expression) [OVER ...]	PERCENTILE_CONT( value_expression, percentile [ {RESPECT | IGNORE} NULLI] ) OVER()
PERCENTILE_DISC(percentile) WITHIN GROUP (ORDER BY value_expression) [OVER ...]	PERCENTILE_DISC( value_expression, percentile [ {RESPECT | IGNORE} NULLI] ) 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 SKEW di Snowflake.
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 trasmettere VARCHAR in valori in virgola mobile.	VAR_POP([DISTINCT] expression) [OVER ...]
VARIANCE_POP([DISTINCT] expression) [OVER ...] Nota: Snowflake supporta la possibilità di trasmettere VARCHAR in valori in virgola mobile.	VAR_POP([DISTINCT] expression) [OVER ...]
VAR_SAMP([DISTINCT] expression) [OVER ...] Nota: Snowflake supporta la possibilità di trasmettere VARCHAR in valori in virgola mobile.	VAR_SAMP([DISTINCT] expression) [OVER ...]
VARIANCE([DISTINCT] expression) [OVER ...] Nota: Snowflake supporta la possibilità di trasmettere VARCHAR in valori in virgola mobile.	VARIANCE([DISTINCT] expression) [OVER ...]

BigQuery offre inoltre le seguenti funzioni aggregate, dati aggregati e aggregati approssimativi che non hanno un analogo diretto in Snowflake:

• COUNTIF
• ARRAY_CONCAT_AGG
• HLL_COUNT.MERGE

Funzioni di espressione bit per bit

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

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

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

Funzioni di espressione condizionale

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

Snowflake	BigQuery
expression [ NOT ] BETWEEN lower AND upper	(expression >= lower AND expression <= upper)
BOOLAND(expression1, expression2) Nota: Snowflake consente di trattare 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 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 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 pari a zero.	BigQuery non supporta un'alternativa diretta a BOOLXOR. di Snowflake
CASE [expression] WHEN condition1 THEN result1 [WHEN condition2 THEN result2] [...] [ELSE result3] END	CASE [expression] WHEN condition1 THEN result1 [WHEN condition2 THEN result2] [...] [ELSE result3] END
COALESCE(expr1, expr2, [,...]) Nota: Snowflake richiede almeno due espressioni. BigQuery ne richiede solo uno.	COALESCE(expr1, [,...])
DECODE(expression, search1, result1, [search2, result2...] [,default])	CASE [expression] WHEN condition1 THEN result1 [WHEN condition2 THEN result2] [...] [ELSE result3] END Nota: BigQuery supporta le sottoquery nelle istruzioni di condizione. Può essere utilizzato per riprodurre DECODE di Snowflake. L'utente deve utilizzare IS NULL anziché = NULL per trovare corrispondenze di espressioni di selezione NULL con 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 seguente tabella mostra le mappature tra le funzioni di contesto comuni di Snowflake 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 Verrà restituita una tabella dei nomi di progetto. Non si tratta di un confronto diretto.
CURRENT_DATE[()] Nota: Snowflake non applica il comando "()" 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 località più generalizzati rispetto a CURRENT_REGION() di Snowflake. Non si tratta di un confronto diretto.
CURRENT_ROLE()	Concetto non utilizzato in BigQuery
CURRENT_SCHEMA()	SELECT schema_name FROM INFORMATION_SCHEMA.SCHEMATA Questa operazione restituisce una tabella di tutti i set di dati (chiamati anche schemi) disponibili nel progetto o nella regione. Non si tratta di 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 prestazione, tipo di inizio/fine e così via.
CURRENT_TIME[([frac_sec_prec])] Nota: Snowflake consente una precisione al secondo frazionaria facoltativa. I valori validi sono compresi tra 0 e 9 nanosecondi. Il valore predefinito è 9. Per rispettare ANSI, questa funzione può essere chiamata senza "()".	CURRENT_TIME()
CURRENT_TIMESTAMP[([frac_sec_prec])] Nota: Snowflake consente una precisione al secondo frazionaria facoltativa. I valori validi sono compresi tra 0 e 9 nanosecondi. Il valore predefinito è 9. Per garantire la conformità con 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 per tipo di prestazione, tipo di inizio/fine e così via.
CURRENT_USER[()] Nota: Snowflake non applica il comando "()" 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 per tipo di prestazione, tipo di inizio/fine e così via.
LAST_TRANSACTION()	SELECT job_id FROM INFORMATION_SCHEMA.JOBS_BY_* Nota: INFORMATION_SCHEMA.JOBS_BY_* di BigQuery consente di cercare gli ID job per tipo di prestazione, tipo di inizio/fine e così via.
LOCALTIME() Nota: Snowflake non applica il comando "()" 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 seguente tabella mostra le mappature tra le funzioni di conversione comuni di Snowflake e i relativi equivalenti 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 tramite il tipo di dati VARIANT. BigQuery non ha un'alternativa al tipo di dati VARIANT.	TO_HEX(CAST(expression AS BYTES)) TO_BASE64(CAST(expression AS BYTES)) CAST(expression AS BYTES) Nota: la trasmissione predefinita di BigQuery in STRING utilizza la codifica UTF-8. Snowflake non dispone di un'opzione per supportare la codifica BASE32.
TO_BOOLEAN(expression) Nota: INT64 TRUE: altrimenti, FALSE: 0 STRING TRUE: "true"/"t"/"yes"/"y"/"on"/"1", FALSE: "false"/"f"/"no"/"n"/"off"/"0"	CAST(expression AS BOOL) Nota: INT64 TRUE: altrimenti, FALSE: 0 STRING TRUE: "true", FALSE: "false"
TO_CHAR(expression[, format]) TO_VARCHAR(expression[, format]) Nota: i modelli di formato di Snowflake sono disponibili qui. BigQuery non ha un'alternativa al tipo di dati VARIANT.	CAST(expression AS STRING) Nota: l'espressione di input di BigQuery può essere formattata utilizzando FORMAT_DATE, FORMAT_DATETIME, FORMAT_TIME o FORMAT_TIMESTAMP.
TO_DATE(expression[, format]) DATE(expression[, format]) Nota: Snowflake supporta la possibilità di convertire direttamente i tipi INTEGER in tipi DATE. I modelli di formato di Snowflake sono disponibili qui. BigQuery non ha un'alternativa al tipo di dati VARIANT.	CAST(expression AS DATE) Nota: l'espressione di input di BigQuery può essere formattata utilizzando FORMAT, FORMAT_DATETIME o FORMAT_TIMESTAMP.
TO_DECIMAL(expression[, format] [,precision[, scale]] TO_NUMBER(expression[, format] [,precision[, scale]] TO_NUMERIC(expression[, format] [,precision[, scale]] Nota: i modelli di formato di Snowflake per i tipi di dati DECIMAL, NUMBER e NUMERIC sono disponibili qui. BigQuery non ha un'alternativa al tipo di dati VARIANT.	ROUND(CAST(expression AS NUMERIC) , x) Nota: l'espressione di input di BigQuery può essere formattata utilizzando FORMAT.
TO_DOUBLE(expression[, format]) Nota: i modelli di formato di Snowflake per i DOUBLE tipi di dati sono disponibili qui. BigQuery non ha un'alternativa al tipo di dati VARIANT.	CAST(expression AS FLOAT64) Nota: l'espressione di input di BigQuery può essere formattata utilizzando FORMAT.
TO_JSON(variant_expression)	BigQuery non ha un'alternativa al tipo di dati VARIANT di Snowflake.
TO_OBJECT(variant_expression)	BigQuery non ha un'alternativa al tipo di dati VARIANT di Snowflake.
TO_TIME(expression[, format]) TIME(expression[, format]) Nota: i modelli di formato di Snowflake per i STRING tipi di dati sono disponibili qui. BigQuery non ha un'alternativa al tipo di dati VARIANT.	CAST(expression AS TIME) Nota: BigQuery non 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/non incluso tramite i parametri FORMAT_TIMESTAMP.
TO_VARIANT(expression)	BigQuery non ha un'alternativa al tipo di dati VARIANT di Snowflake.
TO_XML(variant_expression)	BigQuery non ha un'alternativa al tipo di dati VARIANT di Snowflake.
TRY_CAST(expression AS type)	SAFE_CAST(expression AS type)
TRY_TO_BINARY(expression[, format])	TO_HEX(SAFE_CAST(expression AS BYTES)) TO_BASE64(SAFE_CAST(expression AS BYTES)) SAFE_CAST(expression AS BYTES)
TRY_TO_BOOLEAN(expression)	SAFE_CAST(expression AS BOOL)
TRY_TO_DATE(expression)	SAFE_CAST(expression AS DATE)
TRY_TO_DECIMAL(expression[, format] [,precision[, scale]] TRY_TO_NUMBER(expression[, format] [,precision[, scale]] TRY_TO_NUMERIC(expression[, format] [,precision[, scale]]	ROUND( SAFE_CAST(expression AS NUMERIC) , x)
TRY_TO_DOUBLE(expression)	SAFE_CAST(expression AS FLOAT64)
TRY_TO_TIME(expression)	SAFE_CAST(expression AS TIME)
TRY_TO_TIMESTAMP(expression) TRY_TO_TIMESTAMP_LTZ(expression) TRY_TO_TIMESTAMP_NTZ(expression) TRY_TO_TIMESTAMP_TZ(expression)	SAFE_CAST(expression AS TIMESTAMP)

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

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

Funzioni di generazione dei dati

La seguente tabella mostra le mappature tra le funzioni di generazione dati comuni di 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 definite dall'utente permanenti per creare un equivalente a UNIFORM di Snowflake. Esempio qui.
UUID_STRING([uuid, name]) Nota: Snowflake restituisce 128 bit casuali. Snowflake supporta gli UUID sia della versione 4 (casuale) che della versione 5 (con nome).	GENERATE_UUID() Nota: BigQuery restituisce 122 bit casuali. BigQuery supporta solo gli UUID versione 4.
ZIPF(s, N, gen)	BigQuery non supporta un confronto diretto con ZIPF. di Snowflake

Funzioni di data e ora

La seguente tabella mostra le mappature tra le funzioni di data e ora comuni di Snowflake con i relativi equivalenti BigQuery. I dati e le funzioni temporali di BigQuery includono funzioni di data, funzioni di data/ora, funzioni di tempo e funzioni di 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: source_timezone è sempre UTC in BigQuery
DATE_FROM_PARTS(year, month, day) Nota: Snowflake supporta date extra e negative. Ad esempio, DATE_FROM_PARTS(2000, 1 + 24, 1) restituisce il 1° gennaio 2002. Questa operazione non è supportata in BigQuery.	DATE(year, month, day) DATE(timestamp_expression[, timezone]) DATE(datetime_expression)
DATE_PART(part, dateOrTime) Nota: Snowflake supporta i tipi di parte ISO, nanosecondi ed epoca secondo/millisecondo/microsecondo/nanosecondi del giorno della settimana. BigQuery non lo fa. Consulta l'elenco completo dei tipi di componenti Snowflake qui.	EXTRACT(part FROM dateOrTime) Nota: BigQuery supporta i tipi di parte settimanale(<weekday>), microsecondi e millisecondi. Snowflake no. Consulta l'elenco completo dei tipi di parti BigQuery qui e qui.
DATE_TRUNC(part, dateOrTime) Nota: Snowflake supporta il tipo di parte in nanosecondi. BigQuery non lo fa. 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 parte settimana(<weekday>), 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 data, ora e timestamp in questa funzione.	DATE_DIFF( dateExpression1, dateExpression2, part ) DATETIME_DIFF( datetimeExpression1, datetimeExpression2, part ) TIME_DIFF( timeExpression1, timeExpression2, part ) TIMESTAMP_DIFF( timestampExpression1, timestampExpression2, part ) Nota: BigQuery supporta i tipi di parte della settimana(<weekday>) e dell'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 parte ISO, nanosecondi ed epoca secondo/millisecondo/microsecondo/nanosecondi del giorno della settimana. BigQuery non lo fa. Consulta l'elenco completo dei tipi di componenti Snowflake qui.	EXTRACT(part FROM dateOrTime) Nota: BigQuery supporta i tipi di parte settimanale(<weekday>), microsecondi e millisecondi. Snowflake no. Consulta l'elenco completo dei tipi di parti BigQuery qui e qui.
[HOUR, MINUTE, SECOND](timeOrTimestamp)	EXTRACT(part FROM timestamp [AT THE ZONE timezone])
LAST_DAY(dateOrTime[, part])	DATE_SUB( DATE_TRUNC( DATE_ADD(date, INTERVAL 1 part), part), INTERVAL 1 DAY)
MONTHNAME(dateOrTimestamp)	FORMAT_DATE('%b', date) FORMAT_DATETIME('%b', datetime) FORMAT_TIMESTAMP('%b', timestamp)
NEXT_DAY(dateOrTime, dowString)	DATE_ADD( DATE_TRUNC( date, WEEK(dowString)), INTERVAL 1 WEEK) Nota: potrebbe essere necessario riformattare dowString. Ad esempio, "su" di Snowflake sarà "SUNDAY" di BigQuery.
PREVIOUS_DAY(dateOrTime, dowString)	DATE_TRUNC( date, WEEK(dowString) ) Nota: potrebbe essere necessario riformattare dowString. 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 e esatto con TIME_SLICE di Snowflake. Usa DATETINE_TRUNC, TIME_TRUNC e 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 data, ora e timestamp in questa funzione.	DATE_DIFF( dateExpression1, dateExpression2, part ) DATETIME_DIFF( datetimeExpression1, datetimeExpression2, part ) TIME_DIFF( timeExpression1, timeExpression2, part ) TIMESTAMP_DIFF( timestampExpression1, timestampExpression2, part ) Nota: BigQuery supporta i tipi di parte della settimana(<weekday>) e dell'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 l'inserimento dei timestamp 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 data, ora e timestamp in questa funzione.	DATE_DIFF( dateExpression1, dateExpression2, part ) DATETIME_DIFF( datetimeExpression1, datetimeExpression2, part ) TIME_DIFF( timeExpression1, timeExpression2, part ) TIMESTAMP_DIFF( timestampExpression1, timestampExpression2, part ) Nota: BigQuery supporta i tipi di parte della settimana(<weekday>) e dell'anno ISO.
TRUNC(dateOrTime, part) Nota: Snowflake supporta il tipo di parte in nanosecondi. BigQuery non lo fa. 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 parte settimana(<weekday>), 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 analogico diretto in Snowflake:

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

Schema di informazioni e funzioni tabella

BigQuery non supporta concettualmente molte delle funzioni di tabella e di schema di informazioni di Snowflake. Snowflake offre i seguenti schemi di informazioni e funzioni di tabella, 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 delle funzioni di tabella e dello schema di informazioni di BigQuery e Snowflake associate.

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

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

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

Funzioni numeriche

La seguente tabella mostra le mappature tra le funzioni numeriche di Snowflake comuni e i relativi equivalenti 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 precisione o 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 precisione o scala. ROUND non consente di specificare l'arrotondamento per eccesso. TRUNC funziona come sinonimo per i numeri positivi, ma non per i numeri negativi, poiché 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 supporta "uguale a".

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

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

Funzioni di dati semistrutturati

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

Funzioni 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 dall'utente
COLLATION	Funzione definita dall'utente dall'utente
COMPRESS	Funzione definita dall'utente dall'utente
CONCAT(string1, string2)	CONCAT(string1, string2) Nota: CONCAT(...) di BigQuery supporta la concatenazione di un numero qualsiasi di stringhe.
CONTAINS	Funzione definita dall'utente dall'utente
DECOMPRESS_BINARY	Funzione definita dall'utente dall'utente
DECOMPRESS_STRING	Funzione definita dall'utente dall'utente
EDITDISTANCE	Funzione definita dall'utente dall'utente
ENDSWITH	Funzione definita dall'utente dall'utente
HEX_DECODE_BINARY	SAFE_CONVERT_BYTES_TO_STRING( FROM_HEX(<string1>)
HEX_DECODE_STRING	SAFE_CONVERT_BYTES_TO_STRING( FROM_HEX(<string1>)
HEX_ENCODE	TO_HEX( SAFE_CAST(<string1> AS BYTES))
ILIKE	Funzione definita dall'utente dall'utente
ILIKE ANY	Funzione definita dall'utente dall'utente
INITCAP	INITCAP
INSERT	Funzione definita dall'utente dall'utente
LEFT	Funzione definita dall'utente
LENGTH	LENGTH(expression)
LIKE	LIKE
LIKE ALL	Funzione definita dall'utente dall'utente
LIKE ANY	Funzione definita dall'utente dall'utente
LOWER	LOWER(string)
LPAD	LPAD(string1, length[, string2])
LTRIM	LTRIM(string1, trim_chars)
MD5,MD5_HEX	MD5(string)
MD5_BINARY	Funzione definita dall'utente dall'utente
OCTET_LENGTH	Funzione definita dall'utente dall'utente
PARSE_IP	Funzione definita dall'utente dall'utente
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 dall'utente
SHA1,SHA1_HEX	SHA1(string)
SHA1_BINARY	Funzione definita dall'utente dall'utente
SHA2,SHA2_HEX	Funzione definita dall'utente dall'utente
SHA2_BINARY	Funzione definita dall'utente dall'utente
SOUNDEX	Funzione definita dall'utente dall'utente
SPACE	Funzione definita dall'utente dall'utente
SPLIT	SPLIT
SPLIT_PART	Funzione definita dall'utente dall'utente
SPLIT_TO_TABLE	Funzione definita dall'utente dall'utente
STARTSWITH	Funzione definita dall'utente dall'utente
STRTOK	SPLIT(instring, delimiter)[ORDINAL(tokennum)] Nota: l'intero argomento della stringa del delimitatore viene utilizzato come delimitatore singolo. Il delimitatore predefinito è una virgola.
STRTOK_SPLIT_TO_TABLE	Funzione definita dall'utente dall'utente
SUBSTR,SUBSTRING	SUBSTR
TRANSLATE	Funzione definita dall'utente dall'utente
TRIM	TRIM
TRY_BASE64_DECODE_BINARY	Funzione definita dall'utente dall'utente
TRY_BASE64_DECODE_STRING	SUBSTR(string, 0, integer)
TRY_HEX_DECODE_BINARY	SUBSTR(string, -integer)
TRY_HEX_DECODE_STRING	LENGTH(expression)
UNICODE	Funzione definita dall'utente dall'utente
UPPER	UPPER

Funzioni stringa (espressioni regolari)

Snowflake	BigQuery
REGEXP	IF(REGEXP_CONTAINS,1,0)=1
REGEXP_COUNT	ARRAY_LENGTH( REGEXP_EXTRACT_ALL( source_string, pattern ) ) Se position è specificato: ARRAY_LENGTH( REGEXP_EXTRACT_ALL( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern ) ) Nota: BigQuery supporta le espressioni regolari utilizzando la libreria re2. Consulta la documentazione per conoscere la sintassi delle espressioni regolari.
REGEXP_INSTR	IFNULL( STRPOS( source_string, REGEXP_EXTRACT( source_string, pattern) ), 0) Se position è specificato: 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 occurrence è specificato: 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 supporta le espressioni regolari utilizzando la libreria re2. Consulta la documentazione per conoscere la sintassi delle espressioni regolari.
REGEXP_LIKE	IF(REGEXP_CONTAINS,1,0)=1
REGEXP_REPLACE	REGEXP_REPLACE( source_string, pattern, "" ) Se replace_string è specificato: REGEXP_REPLACE( source_string, pattern, replace_string ) Se position è specificato: 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 supporta le espressioni regolari utilizzando la libreria re2. Consulta la documentazione per conoscere la sintassi delle espressioni regolari.
REGEXP_SUBSTR	REGEXP_EXTRACT( source_string, pattern ) Se position è specificato: REGEXP_EXTRACT( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern ) Se occurrence è specificato: REGEXP_EXTRACT_ALL( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern )[SAFE_ORDINAL(occurrence)] Nota: BigQuery supporta le espressioni regolari utilizzando la libreria re2. Consulta la documentazione per conoscere la sintassi delle espressioni regolari.
RLIKE	IF(REGEXP_CONTAINS,1,0)=1

Funzioni di sistema

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

Funzioni tabella

Snowflake		BigQuery
GENERATOR		Funzione definita dall'utente dall'utente
GET_OBJECT_REFERENCES		Funzione definita dall'utente dall'utente
RESULT_SCAN		Funzione definita dall'utente dall'utente
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 dall'utente
CONDITIONAL_TRUE_EVENT		Funzione definita dall'utente dall'utente
CUME_DIST		CUME_DIST
DENSE_RANK		DENSE_RANK
FIRST_VALUE		FIRST_VALUE
LAG		LAG
LAST_VALUE		LAST_VALUE
LEAD		LEAD
NTH_VALUE		NTH_VALUE
NTILE		NTILE
PERCENT_RANK		PERCENT_RANK
RANK		RANK
RATIO_TO_REPORT		Funzione definita dall'utente dall'utente
ROW_NUMBER		ROW_NUMBER
WIDTH_BUCKET		Funzione definita dall'utente dall'utente

BigQuery supporta anche SAFE_CAST(expression AS typename), che restituisce NULL se BigQuery non è in grado di eseguire un cast (ad esempio, SAFE_CAST("apple" AS INT64) restituisce NULL.

Operatori

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

Operatori aritmetici

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

Snowflake	BigQuery
(Unary) (+'5')	CAST("5" AS NUMERIC)
a + b	a + b
(Unary) (-'5')	(-1) * CAST("5" AS NUMERIC) Nota: BigQuery supporta il segno meno unario standard, ma non converte i numeri interi in formato stringa nel 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 sulla scalabilità e sulla 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 logical/boolean operators Snowflake e gli logical/boolean operators di BigQuery sono uguali.

Operatori Set

La seguente tabella mostra le mappature tra gli operatori impostati Snowflake e i relativi equivalenti 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 seguente tabella mostra le mappature tra gli operatori di sottoquery di Snowflake e i relativi equivalenti BigQuery.

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

Sintassi DML

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

Istruzione INSERT

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

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

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

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

Istruzione COPY

Snowflake supporta la copia dei dati dai file delle fasi in una tabella esistente e da una tabella a uno stadio interno denominato, a uno esterno denominato e a una posizione esterna (Amazon S3, Google Cloud Storage o Microsoft Azure).

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

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

Istruzione UPDATE

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 che TRUNCATE TABLE mantengono i dati eliminati utilizzando la funzionalità Viaggio nel tempo di Snowflake a scopo di recupero per il periodo di conservazione dei dati. Tuttavia, DELETE non elimina la cronologia del caricamento dei file esterni e non carica i metadati.

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

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

Istruzione MERGE

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

Le tabelle BigQuery sono limitate a 1000 istruzioni DML al giorno, quindi è necessario consolidare in modo ottimale le istruzioni INSERT, UPDATE e DELETE in una singola istruzione MERGE, come mostrato nella seguente tabella:

Snowflake	BigQuery
MERGE INTO target USING source ON target.key = source.key WHEN MATCHED AND source.filter = 'Filter_exp' THEN UPDATE SET target.col1 = source.col1, target.col1 = source.col2, ... Nota: Snowflake supporta un parametro di sessione ERROR_ON_NONDETERMINISTIC_MERGE per gestire i risultati non deterministici.	MERGE target USING source ON target.key = source.key WHEN MATCHED AND source.filter = 'filter_exp' THEN UPDATE SET target.col1 = source.col1, target.col2 = source.col2, ... Nota: se aggiorni 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 a una directory o 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 caricati in un'area intermedia (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 gestione temporanea e non ha gli equivalenti GET e LIST.

Estratti conto PUT e REMOVE

L'istruzione PUT carica i file di dati (ovvero, le fasi) da una directory locale o una cartella 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 inseriti nell'area intermedia 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 gestione temporanea e non ha gli equivalenti PUT e REMOVE.

Sintassi DDL

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

Database, schema e DDL di condivisione

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

Istruzione CREATE DATABASE

Snowflake supporta la creazione e la gestione di un database tramite i comandi di gestione dei database, mentre BigQuery offre diverse opzioni per la creazione di set di dati, tra cui l'utilizzo di console, interfaccia a riga di comando, librerie client e così via. Questa sezione utilizzerà i comandi dell'interfaccia a riga di comando di BigQuery corrispondenti ai comandi 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, con l'unica differenza che il nome consente 1024 caratteri.
CREATE OR REPLACE DATABASE <name>	La sostituzione del set di dati non è supportata in BigQuery.
CREATE TRANSIENT DATABASE <name>	La creazione di un set di dati temporaneo non è supportata in BigQuery.
CREATE DATABASE IF NOT EXISTS <name>	Concetto non supportato in BigQuery
CREATE DATABASE <name> CLONE <source_db> [ { AT | BEFORE } ( { TIMESTAMP => <timestamp> | OFFSET => <time_difference> | STATEMENT => <id> } ) ]	La clonazione dei set di dati non è ancora supportata in BigQuery.
CREATE DATABASE <name> DATA_RETENTION_TIME_IN_DAYS = <num>	Gli spostamenti nel tempo a livello del set di dati non sono supportati in BigQuery. Tuttavia, è supportato lo spostamento nel tempo per i risultati di tabelle e query.
CREATE DATABASE <name> DEFAULT_DDL_COLLATION = '<collation_specification>'	Le regole di confronto in DDL non sono supportate in BigQuery.
CREATE DATABASE <name> COMMENT = '<string_literal>'	bq mk \ --description "<string_literal>" \ <name>
CREATE DATABASE <name> FROM SHARE <provider_account>.<share_name>	La creazione di set di dati condivisi non è supportata in BigQuery. Tuttavia, gli utenti possono condividere il set di dati tramite Console/UI dopo la sua creazione.
CREATE DATABASE <name> AS REPLICA OF <region>.<account>.<primary_db_name> AUTO_REFRESH_MATERIALIZED_VIEWS_ON_SECONDARY = { TRUE | FALSE } Nota: Snowflake offre l'opzione per la gestione automatica in background delle viste materializzate nel database secondario, che non è supportata in BigQuery.	bq mk --transfer_config \ --target_dataset = <name> \ --data_source = cross_region_copy \ --params=' {"source_dataset_id":"<primary_db_name>" ,"source_project_id":"<project_id>" ,"overwrite_destination_table":"true"}' Nota: BigQuery supporta la copia di set di dati utilizzando BigQuery Data Transfer Service. Leggi qui i prerequisiti per la copia di un set di dati.

BigQuery offre anche le seguenti opzioni del 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>

Istruzione ALTER DATABASE

Questa sezione utilizzerà i comandi dell'interfaccia a riga di comando di BigQuery corrispondenti ai comandi 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 dei dati e delle regole di confronto 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.

Istruzione DROP DATABASE

Questa sezione utilizzerà il comando dell'interfaccia a riga di comando di 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 ne comporta la rimozione definitiva dal sistema. Una versione del database eliminato viene conservata per il numero di giorni specificato dal parametro DATA_RETENTION_TIME_IN_DAYS per il database.	bq rm -r -f -d <name> Where -r è la rimozione di tutti gli oggetti nel set di dati -f is to skip confirmation for execution -d indica il set di dati Nota: in BigQuery, l'eliminazione di un set di dati è definitiva. Inoltre, l'unione a cascata non è supportata a livello del set di dati poiché tutti i dati e gli oggetti nel set di dati vengono eliminati.

Snowflake supporta anche il comando UNDROP DATASET, che ripristina la versione più recente di un set di dati eliminato. Questa funzionalità non è attualmente supportata in BigQuery a livello di set di dati.

Istruzione USE DATABASE

Snowflake offre la possibilità di impostare il database per una sessione utente utilizzando il comando USE DATABASE. Ciò elimina la necessità di specificare nomi completi degli oggetti nei comandi SQL. BigQuery non offre alternative al comando USE DATABASE di Snowflake.

Istruzione SHOW DATABASE

Questa sezione utilizzerà il comando dell'interfaccia a riga di comando di BigQuery corrispondente al comando Snowflake per risolvere la differenza nell'istruzione SHOW.

Snowflake	BigQuery
SHOW DATABASES Nota: Snowflake offre una singola 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, gli ACL e le etichette di un set di dati. BigQuery fornisce inoltre 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, è supportato il filtro per etichette.
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ò essere superiore a 10.000.	bq ls \ --max_results <rows> Nota: per impostazione predefinita, BigQuery mostra solo 50 risultati.

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

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

Gestione di SCHEMA

Snowflake fornisce più comandi di gestione dello schema simili ai suoi comandi di gestione del database. Questo concetto di creazione e gestione dello schema non è supportato in BigQuery.

Tuttavia, BigQuery consente di specificare lo schema di una tabella quando carichi 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 della condivisione simili ai suoi comandi di database e gestione degli schemi. Questo concetto di creazione e gestione della condivisione non è supportato in BigQuery.

DDL tabella, visualizzazione e sequenza

Istruzione CREATE TABLE

La maggior parte delle istruzioni CREATE TABLE di Snowflake è compatibile con BigQuery, ad eccezione dei 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 si trova: [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 vincoli di tabella UNIQUE, PRIMARY KEY o FOREIGN KEY. Per ottenere un'ottimizzazione simile a quella offerta da questi vincoli durante l'esecuzione delle query, esegui il partizionamento e il clustering delle 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 nomi delle colonne, tipi di dati e vincoli NOT NULL in una nuova tabella.
CREATE TABLE table_name ( col1 data_type1 ) BACKUP NO Nota:in Snowflake, l'impostazione BACKUP NO è specificata per "risparmiare tempo di elaborazione durante la creazione di snapshot e il ripristino dagli snapshot, nonché per ridurre lo spazio di archiviazione".	L'opzione per la tabella BACKUP NO non è utilizzata né necessaria perché BigQuery conserva automaticamente fino a 7 giorni delle versioni cronologiche di tutte le tabelle, senza alcun effetto sui tempi di elaborazione o sullo spazio di archiviazione fatturato.
CREATE TABLE table_name ( col1 data_type1 ) table_attributes dove table_attributes si trova: [DISTSTYLE {AUTO|EVEN|KEY|ALL}] [DISTKEY (column_name)] [[COMPOUND|INTERLEAVED] SORTKEY (column_name [, ...])]	BigQuery supporta il clustering, che consente l'archiviazione delle 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 già esistente.

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

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

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

Istruzione ALTER TABLE

Questa sezione utilizzerà i comandi dell'interfaccia a riga di comando di BigQuery corrispondenti ai comandi Snowflake per risolvere le differenze nelle istruzioni ALTER per le tabelle.

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

Inoltre, Snowflake offre opzioni di clustering, colonne e vincoli per la modifica delle tabelle non supportate da BigQuery.

Estratti conto DROP TABLE e UNDROP TABLE

Questa sezione utilizzerà il comando dell'interfaccia a riga di comando di BigQuery corrispondente al comando Snowflake per risolvere la differenza nelle istruzioni DROP e UNDROP.

Snowflake	BigQuery
DROP TABLE [IF EXISTS] <table_name> [CASCADE | RESTRICT] Nota: in Snowflake, la rimozione 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 consiste nel rimuovere tutti gli oggetti nel set di dati -f significa saltare la conferma per l'esecuzione -d indica il set di dati Nota: in BigQuery anche l'eliminazione di una tabella non è definitiva, ma al momento uno snapshot viene conservato 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 il timestamp UNIX (in millisecondi) relativo all'esistenza della tabella. Poi, copia la tabella corrispondente a quel timestamp in una nuova tabella. La nuova tabella deve avere un nome diverso da quello della tabella eliminata.

Istruzione CREATE EXTERNAL TABLE

BigQuery consente di creare tabelle esterne permanenti e temporanee e 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 set di uno o più file in una fase esterna specificata.

Questa sezione utilizzerà il comando dell'interfaccia a riga di comando di 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 la lettura temporanea dei file contenenti dati e la specifica delle opzioni del 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]. I file temporanei da leggere e la specifica delle opzioni del tipo di formato non sono supportati 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 le opzioni di parametri opzionali fornite da Snowflake per la creazione di tabelle esterne. Per il partizionamento, BigQuery supporta l'uso della pseudo colonna _FILE_NAME per creare tabelle/visualizzazioni partizionate sopra le tabelle esterne. Per maggiori informazioni, consulta Eseguire una query sulla pseudo colonna _FILE_NAME.

Inoltre, BigQuery supporta anche l'esecuzione di query su dati partizionati esternamente nei formati AVRO, PARQUET, ORC, JSON e CSV archiviati su Google Cloud Storage utilizzando un layout di partizionamento hive predefinito.

Istruzione CREATE VIEW

La seguente tabella 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 ...
Funzionalità non supportata	CREATE VIEW IF NOT EXISTS view_name OPTIONS(view_option_list) AS SELECT ...
CREATE VIEW view_name AS SELECT ... WITH NO SCHEMA BINDING	In BigQuery, per creare una vista, tutti gli oggetti a cui viene fatto riferimento devono già esistere. BigQuery consente di eseguire query su origini dati esterne.

Istruzione CREATE SEQUENCE

Le sequenze non vengono utilizzate in BigQuery. Per eseguire questa operazione, puoi utilizzare il metodo batch riportato di seguito. Per ulteriori informazioni sulle chiavi surrogate e sul cambio lento delle dimensioni (SCD), consulta le seguenti guide:

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

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

DDL durante il caricamento e l'unload dei dati

Snowflake supporta il caricamento e l'unload dei dati tramite comandi di gestione di fasi, formato file e pipeline. BigQuery offre inoltre varie opzioni per come carico bq, BigQuery Data Transfer Service, estrazione bq e così via. Questa sezione evidenzia le differenze nell'utilizzo di queste metodologie per il caricamento e l'unload dei dati.

DDL account e sessione

I concetti relativi ad account e sessione di Snowflake non sono supportati in BigQuery. BigQuery consente di gestire gli 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 relativo risultato sotto forma di valore

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

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

Sintassi CREATE FUNCTION

La seguente tabella indica le differenze nella sintassi di creazione delle funzioni definite dall'utente 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 UDF SQL di BigQuery, il tipo di dati restituito è facoltativo. BigQuery deduce 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:nelle UDF SQL di BigQuery, la restituzione del tipo di tabella non è attualmente supportata, ma è nella roadmap del prodotto e lo sarà 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 della funzione definita dall'utente solo agli utenti autorizzati, ovvero agli utenti a cui è stato concesso il ruolo proprietario della vista.	CREATE FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Nota: la sicurezza della funzione non è un parametro configurabile in BigQuery. BigQuery supporta la creazione di ruoli e autorizzazioni IAM per limitare l'accesso ai dati sottostanti e alla definizione delle funzioni.
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type [ { CALLED ON NULL INPUT | { RETURNS NULL ON NULL INPUT | STRICT } } ] AS sql_function_definition	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Nota: il comportamento delle funzioni per gli input nulli è gestito implicitamente in BigQuery e non deve essere specificato come opzione separata.
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type [VOLATILE | IMMUTABLE] AS sql_function_definition	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Nota:la volatilità della funzione non è un parametro configurabile in BigQuery. L'intera volatilità della funzione definita dall'utente di BigQuery è equivalente alla volatilità IMMUTABLE di Snowflake, ovvero non esegue ricerche nel database e non utilizza in altro modo informazioni non presenti direttamente nell'elenco di 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 in dollari ($$) is not required or supported in BigQuery. BigQuery implicitly interprets the SQL expression.
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type [COMMENT = '<string_literal>'] AS sql_function_definition	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Note:Adding comments or descriptions in UDFs is currently not supported in BigQuery.
CREATE [OR REPLACE] FUNCTION function_name (x integer, y integer) RETURNS integer AS $$ SELECT x + y $$ Note: Snowflake does not support ANY TYPE for SQL UDFs. However, it supports using VARIANT data types.	CREATE [OR REPLACE] FUNCTION function_name (x ANY TYPE, y ANY TYPE) AS SELECT x + y Note: BigQuery supports using ANY TYPE as argument type. The function will accept an input of any type for this argument. For more information, see templated parameter in BigQuery.

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

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

DROP FUNCTION syntax

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

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

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

Additional function commands

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

ALTER FUNCTION syntax

Snowflake supports the following operations using ALTER FUNCTION syntax.

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

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

DESCRIBE FUNCTION syntax

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

SHOW USER FUNCTIONS syntax

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

Stored procedures

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

CREATE PROCEDURE syntax

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

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

Snowflake	BigQuery
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type AS procedure_definition; Note: Snowflake requires that stored procedures return a single value. Hence, return data type is a required option.	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_mode arg_name arg_data_type[,..]]) BEGIN procedure_definition END; arg_mode: IN | OUT | INOUT Note: BigQuery doesn't support a return type for stored procedures. Also, it requires specifying argument mode for each argument passed.
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type AS $$ javascript_code $$;	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN statement_list END;
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type [{CALLED ON NULL INPUT | {RETURNS NULL ON NULL INPUT | STRICT}}] AS procedure_definition;	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN procedure_definition END; Nota: il comportamento della procedura per gli input nulli viene gestito implicitamente in BigQuery e non deve essere specificato come opzione separata.
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type [VOLATILE | IMMUTABLE] AS procedure_definition;	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN procedure_definition END; Nota:la volatilità della procedura non è un parametro configurabile in BigQuery. Equivale alla volatilità di 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:al momento, l'aggiunta di commenti o descrizioni nelle definizioni delle procedure non è 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 del chiamante o del proprietario 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 considera la query riuscita e non intraprende alcuna azione se esiste già una funzione con lo stesso nome.

Sintassi DROP PROCEDURE

La seguente tabella indica le differenze nella sintassi 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 (tipo di dati dell'argomento) della procedura per eliminarla.

BigQuery richiede di specificare il project_name se la procedura non si trova nel progetto attuale.

Comandi di procedura aggiuntivi

Snowflake fornisce comandi aggiuntivi come ALTER PROCEDURE, DESC[RIBE] PROCEDURE e SHOW PROCEDURES per gestire le stored procedure. Non sono attualmente supportate in BigQuery.

Istruzioni SQL per metadati e transazioni

Snowflake	BigQuery
BEGIN [ { WORK | TRANSACTION } ] [ NAME <name> ]; START_TRANSACTION [ name <name> ];	BigQuery utilizza sempre l'isolamento snapshot. Per maggiori dettagli, consulta Garanzie di coerenza altrove 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 a più istruzioni e multiriga

Sia Snowflake che BigQuery supportano le transazioni (sessioni) e, di conseguenza, supportano istruzioni separate da punto e virgola che vengono eseguite insieme in modo coerente. Per maggiori informazioni, consulta Transazioni con più estratti conto.

Colonne dei metadati per i file temporanei

Snowflake genera automaticamente metadati per i file nelle fasi interne ed esterne. Questi metadati possono essere sottoposti a query e caricati in una tabella insieme a colonne di dati normali. Puoi utilizzare le seguenti colonne di metadati:

• METADATI$FILENAME
• METADATA$FILE_ROW_NUMBER

Garanzie di coerenza e isolamento delle transazioni

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

Transazioni

A ogni transazione Snowflake viene assegnata un'ora di inizio univoca (inclusi i millisecondi) 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 si trovano entrambe nella stessa transazione, anche se le modifiche non sono state ancora confermate. Le transazioni Snowflake acquisiscono blocchi sulle risorse (tabelle) durante la modifica della risorsa. Gli utenti possono modificare il tempo massimo di attesa per un estratto conto bloccato. Le istruzioni DML vengono inviate automaticamente se il parametro AUTOCOMMIT è attivato.

BigQuery inoltre supporta le transazioni. BigQuery aiuta a garantire il controllo ottimistico della contemporaneità (il primo a eseguire il commit delle vittorie) tramite l'isolamento degli snapshot, in cui una query legge gli ultimi dati di cui è stato eseguito il commit prima dell'avvio. Questo approccio garantisce lo stesso livello di coerenza per riga, per mutazione e in tutte le righe della stessa istruzione DML, evitando però i deadlock. In caso di più aggiornamenti DML sulla stessa tabella, BigQuery passa al controllo della contemporaneità pessimistica. I job di caricamento possono essere eseguiti in modo completamente indipendente e aggiunti alle tabelle. Tuttavia, BigQuery non fornisce ancora una sessione o un confine di transazione espliciti.

Esegui il rollback

Se la sessione di una transazione Snowflake viene terminata in modo imprevisto prima che venga eseguito il commit o il rollback della transazione, la transazione viene lasciata in uno stato scollegato. L'utente deve eseguire SYSTEM$ABORT_TRANSACTION per interrompere la transazione scollegata oppure Snowflake eseguirà il rollback della transazione scollegata dopo quattro ore di inattività. Se si verifica un deadlock, Snowflake rileva il deadlock e seleziona l'istruzione più recente di cui eseguire il rollback. Se l'istruzione DML in una transazione aperta in modo esplicito non va a buon fine, viene eseguito il rollback delle modifiche, ma la transazione viene mantenuta aperta fino al commit o al rollback. Non è possibile eseguire il rollback delle istruzioni DDL in Snowflake poiché vengono confermate automaticamente.

BigQuery supporta l'istruzione ROLLBACK TRANSACTION. Non è presente un'istruzione ABORT in BigQuery.

Limiti per i database

Consulta sempre la documentazione pubblica di BigQuery per le quote e i limiti più recenti. Contattando il team di assistenza Cloud per incrementare le quote per gli utenti con volumi elevati,

Per tutti gli account Snowflake sono previsti dei limiti flessibili impostati per impostazione predefinita. I limiti flessibili vengono impostati durante la creazione dell'account e possono variare. Molti limiti flessibili di Snowflake possono essere aumentati tramite il team dedicato all'account Snowflake o un ticket di assistenza.

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

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