Guia de tradução de SQL do Snowflake

Este documento detalha as semelhanças e as diferenças na sintaxe SQL entre o Snowflake e o BigQuery para ajudar a acelerar o planeamento e a execução da transferência do seu EDW (Enterprise Data Warehouse) para o BigQuery. O armazenamento de dados do Snowflake foi concebido para funcionar com a sintaxe SQL específica do Snowflake. Os scripts escritos para o Snowflake podem ter de ser alterados antes de os poder usar no BigQuery, porque os dialetos de SQL variam entre os serviços. Use a tradução de SQL em lote para migrar os seus scripts SQL em massa ou a tradução de SQL interativa para traduzir consultas ad hoc. O SQL do Snowflake é suportado por ambas as ferramentas na pré-visualização.

Nota: em alguns casos, não existe um mapeamento direto entre um elemento SQL no Snowflake e no BigQuery. No entanto, na maioria dos casos, pode alcançar a mesma funcionalidade no BigQuery que no Snowflake através de meios alternativos, conforme mostrado nos exemplos neste documento.

Tipos de dados

Esta secção mostra os equivalentes entre os tipos de dados no Snowflake e no BigQuery.

Floco de neve	BigQuery	Notas
NUMBER/ DECIMAL/NUMERIC	NUMERIC/BIGNUMERIC	Pode ser mapeado para NUMERIC ou BIGNUMERIC, consoante a precisão e a escala. O tipo de dados NUMBER no Snowflake suporta 38 dígitos de precisão e 37 dígitos de escala. A precisão e a escala podem ser especificadas de acordo com o utilizador. O BigQuery suporta NUMERIC e BIGNUMERIC com precisão e escala especificadas opcionalmente dentro de determinados limites.
INT/INTEGER	BIGNUMERIC	INT/INTEGER e todos os outros tipos de dados semelhantes a INT, como BIGINT, TINYINT, SMALLINT, BYTEINT, representam um alias para o tipo de dados NUMBER, em que a precisão e a escala não podem ser especificadas e são sempre NUMBER(38, 0) A opção de configuração REWRITE_ZERO_SCALE_NUMERIC_AS_INTEGER pode ser usada para converter INTEGER e tipos relacionados em INT64.
BIGINT	BIGNUMERIC
SMALLINT	BIGNUMERIC
TINYINT	BIGNUMERIC
BYTEINT	BIGNUMERIC
FLOAT/ FLOAT4/ FLOAT8	FLOAT64	O tipo de dados FLOAT no Snowflake estabelece "NaN" como > X, em que X é qualquer valor FLOAT (exceto o próprio "NaN"). O tipo de dados FLOAT no BigQuery estabelece "NaN" como < X, onde X é qualquer valor FLOAT (exceto o próprio "NaN").
DOUBLE/ DOUBLE PRECISION/ REAL	FLOAT64	O tipo de dados DOUBLE no Snowflake é sinónimo do tipo de dados FLOAT no Snowflake, mas é frequentemente apresentado incorretamente como FLOAT. É armazenado corretamente como DOUBLE.
VARCHAR	STRING	O tipo de dados VARCHAR no Snowflake tem um comprimento máximo de 16 MB (não comprimido). Se o comprimento não for especificado, o valor predefinido é o comprimento máximo. O tipo de dados STRING no BigQuery é armazenado como Unicode codificado em UTF-8 de comprimento variável. O comprimento máximo é de 16 000 carateres.
CHAR/CHARACTER	STRING	O tipo de dados CHAR no Snowflake tem um comprimento máximo de 1.
STRING/TEXT	STRING	O tipo de dados STRING no Snowflake é sinónimo de VARCHAR do Snowflake.
BINARY	BYTES
VARBINARY	BYTES
BOOLEAN	BOOL	O tipo de dados BOOL no BigQuery só pode aceitar TRUE/FALSE, ao contrário do tipo de dados BOOL no Snowflake, que pode aceitar TRUE/FALSE/NULL.
DATE	DATE	O tipo DATE no Snowflake aceita os formatos de data mais comuns, ao contrário do tipo DATE no BigQuery, que só aceita datas no formato "AAAA-[M]M-[D]D".
TIME	TIME	O tipo TIME no Snowflake suporta 0 a 9 nanosegundos de precisão, enquanto o tipo TIME no BigQuery suporta 0 a 6 nanosegundos de precisão.
TIMESTAMP	DATETIME	TIMESTAMP é um alias configurável pelo utilizador que é predefinido como TIMESTAMP_NTZ, que é mapeado para DATETIME no BigQuery.
TIMESTAMP_LTZ	TIMESTAMP
TIMESTAMP_NTZ/DATETIME	DATETIME
TIMESTAMP_TZ	TIMESTAMP
OBJECT	JSON	O tipo OBJECT no Snowflake não suporta valores com tipos explícitos. Os valores são do tipo VARIANT.
VARIANT	JSON	O tipo OBJECT no Snowflake não suporta valores com tipos explícitos. Os valores são do tipo VARIANT.
ARRAY	ARRAY<JSON>	O tipo ARRAY no Snowflake só pode suportar tipos VARIANT, enquanto o tipo ARRAY no BigQuery pode suportar todos os tipos de dados, exceto uma matriz.

O BigQuery também tem os seguintes tipos de dados que não têm um análogo direto no Snowflake:

• DATETIME
• GEOGRAPHY

Sintaxe de consulta e operadores de consulta

Esta secção aborda as diferenças na sintaxe de consulta entre o Snowflake e o BigQuery.

SELECT declaração

A maioria das declarações do Snowflake são compatíveis com o BigQuery.SELECT A tabela seguinte contém uma lista de diferenças menores.

Floco de neve		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: o Snowflake suporta a criação e a referência de um alias na mesma declaração 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)

Os alias e os identificadores do Snowflake não são sensíveis a maiúsculas e minúsculas por predefinição. Para preservar a capitalização, inclua os alias e os identificadores entre aspas (").

FROM cláusula

Uma cláusula FROM numa consulta especifica as tabelas, as vistas, a subconsulta ou as funções de tabela possíveis a usar numa declaração SELECT. Todas estas referências de tabelas são suportadas no BigQuery.

A tabela seguinte contém uma lista de pequenas diferenças.

Floco de neve		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: o BigQuery não tem uma alternativa direta ao BEFORE do Snowflake que use um ID da declaração. O valor de timestamp não pode ser superior a 7 dias antes da data/hora atual.
@[namespace]<stage_name>[/path]		O BigQuery não suporta o conceito de ficheiros preparados.
SELECT* FROM table START WITH predicate CONNECT BY [PRIOR] col1 = [PRIOR] col2 [, ...] ...		O BigQuery não oferece uma alternativa direta ao CONNECT BY do Snowflake.

As tabelas do BigQuery podem ser referenciadas na cláusula FROM através de:

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

O BigQuery também suporta referências de tabelas adicionais:

• Versões históricas da definição da tabela e das linhas que usam FOR SYSTEM_TIME AS OF
• Caminhos de campos ou qualquer caminho que seja resolvido para um campo num tipo de dados (ou seja, um STRUCT)
• Matrizes reduzidas

WHERE cláusula

As cláusulas do Snowflake WHERE e do BigQuery WHERE são idênticas, exceto no seguinte:

Floco de neve		BigQuery
SELECT col1, col2 FROM table1, table2 WHERE col1 = col2(+)		SELECT col1, col2 FROM table1 INNER JOIN table2 ON col1 = col2 Nota: o BigQuery não suporta a sintaxe (+) para JOINs

JOIN tipos

O Snowflake e o BigQuery suportam os seguintes tipos de junção:

• [INNER] JOIN
• LEFT [OUTER] JOIN
• RIGHT [OUTER] JOIN
• FULL [OUTER] JOIN
• CROSS JOINe a "junção cruzada" implícita equivalente

O Snowflake e o BigQuery suportam a cláusulaONandUSING.

A tabela seguinte contém uma lista de pequenas diferenças.

Floco de neve		BigQuery
SELECT col1 FROM table1 NATURAL JOIN table2		SELECT col1 FROM table1 INNER JOIN table2 USING (col1, col2 [, ...]) Nota: no BigQuery, as cláusulas JOIN requerem uma condição JOIN, a menos que seja um CROSS JOIN ou uma das tabelas associadas seja um campo num tipo de dados ou numa matriz.
SELECT ... FROM table1 AS t1, LATERAL ( SELECT* FROM table2 AS t2 WHERE t1.col = t2.col ) Nota: ao contrário da saída de uma junção não lateral, a saída de uma junção lateral inclui apenas as linhas geradas a partir da vista inline. Não é necessário juntar as linhas do lado esquerdo às do lado direito, porque as linhas do lado esquerdo já foram tidas em conta ao serem transmitidas para a vista em linha.		SELECT ... FROM table1 as t1 LEFT JOIN table2 as t2 ON t1.col = t2.col Nota: o BigQuery não suporta uma alternativa direta para LATERAL JOINs.

WITH cláusula

Uma cláusula BigQuery WITH contém uma ou mais subconsultas com nome que são executadas sempre que uma declaração SELECT subsequente faz referência às mesmas. As cláusulas Snowflake WITH comportam-se da mesma forma que o BigQuery, com a exceção de que o BigQuery não suporta WITH RECURSIVE.

GROUP BY cláusula

As cláusulas GROUP BY do Snowflake suportam GROUP BY, GROUP BY ROLLUP, GROUP BY GROUPING SETS, e GROUP BY CUBE>, enquanto as cláusulas GROUP BY do BigQuery suportam GROUP BY, GROUP BY ALL, GROUP BY ROLLUP, GROUP BY GROUPING SETS, e GROUP BY CUBE.

Floco de neve HAVING e BigQuery HAVING são sinónimos. Tenha em atenção que a HAVING ocorre após a GROUP BY e a agregação, e antes da ORDER BY.

Floco de neve		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: o Snowflake permite até 128 conjuntos de agrupamentos no mesmo bloco de consulta		SELECT col1 as one, col2 as two FROM table GROUP BY GROUPING SETS (one, 2)
SELECT col1 as one, col2 as two FROM table GROUP BY CUBE (one,2) Nota: o Snowflake permite até 7 elementos (128 conjuntos de agrupamento) em cada cubo		SELECT col1 as one, col2 as two FROM table GROUP BY CUBE (one, 2)

ORDER BY cláusula

Existem algumas diferenças menores entre as cláusulas Snowflake ORDER BY e as cláusulas BigQuery ORDER BY.

Floco de neve		BigQuery
No Snowflake, os NULLs são classificados por último por predefinição (ordem ascendente).		No BigQuery, os valores NULLS são classificados em primeiro lugar por predefinição (por ordem ascendente).
Pode especificar se os valores NULL devem ser ordenados primeiro ou por último usando NULLS FIRST ou NULLS LAST, respetivamente.		Não existe um equivalente para especificar se os valores NULL devem ser os primeiros ou os últimos no BigQuery.

LIMIT/FETCH cláusula

A cláusula LIMIT/FETCH no Snowflake restringe o número máximo de linhas devolvidas por uma declaração ou uma subconsulta. LIMIT (sintaxe do Postgres) e FETCH (sintaxe ANSI) produzem o mesmo resultado.

No Snowflake e no BigQuery, a aplicação de uma cláusula LIMIT a uma consulta não afeta a quantidade de dados lidos.

Floco de neve		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: NULL, string vazia ('') e $$$$ valores são aceites e tratados como "ilimitados". A utilização principal destina-se a conetores e controladores.		SELECT col1, col2 FROM table ORDER BY col1 LIMIT count OFFSET start Nota: o BigQuery não suporta o FETCH. LIMIT substitui FETCH. Nota: no BigQuery, OFFSET tem de ser usado em conjunto com um LIMIT count. Certifique-se de que define o valor countINT64 para o número mínimo de linhas ordenadas necessárias para o melhor desempenho. Ordenar todas as linhas de resultados desnecessariamente leva a um pior desempenho da execução de consultas.

QUALIFY cláusula

A cláusula QUALIFY no Snowflake permite-lhe filtrar resultados para funções de janela semelhantes ao que HAVING faz com funções de agregação e cláusulas GROUP BY.

Floco de neve		BigQuery
SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1;		A cláusula QUALIFY do Snowflake com uma função de estatísticas, como ROW_NUMBER(), COUNT() e com OVER PARTITION BY, é expressa no BigQuery como uma cláusula WHERE numa subconsulta que contém o valor de estatísticas. Usar ROW_NUMBER(): SELECT col1, col2 FROM ( SELECT col1, col2 ROW NUMBER() OVER (PARTITION BY col1 ORDER by col2) RN FROM table ) WHERE RN = 1; Usar ARRAY_AGG(), que suporta partições maiores: SELECT result.* FROM ( SELECT ARRAY_AGG(table ORDER BY table.col2 DESC LIMIT 1) [OFFSET(0)] FROM table GROUP BY col1 ) AS result;

Funções

As secções seguintes listam as funções do Snowflake e os respetivos equivalentes no BigQuery.

Funções de agregação

A tabela seguinte mostra os mapeamentos entre funções de agregação, funções analíticas de agregação e funções de agregação aproximadas comuns do Snowflake com os respetivos equivalentes do BigQuery.

Floco de neve	BigQuery
ANY_VALUE([DISTINCT] expression) [OVER ...] Nota: DISTINCT não tem qualquer efeito	ANY_VALUE(expression) [OVER ...]
APPROX_COUNT_DISTINCT([DISTINCT] expression) [OVER ...] Nota: DISTINCT não tem qualquer efeito	APPROX_COUNT_DISTINCT(expression) Nota: o BigQuery não suporta APPROX_COUNT_DISTINCT com funções de janela
APPROX_PERCENTILE(expression, percentile) [OVER ...] Nota: o Snowflake não tem a opção de RESPECT NULLS	APPROX_QUANTILES([DISTINCT] expression,100) [OFFSET((CAST(TRUNC(percentile * 100) as INT64))] Nota: o BigQuery não suporta APPROX_QUANTILES com funções de janela
APPROX_PERCENTILE_ACCUMULATE (expression)	O BigQuery não suporta a capacidade de armazenar o estado intermédio quando prevê valores aproximados.
APPROX_PERCENTILE_COMBINE(state)	O BigQuery não suporta a capacidade de armazenar o estado intermédio quando prevê valores aproximados.
APPROX_PERCENTILE_ESTIMATE(state, percentile)	O BigQuery não suporta a capacidade de armazenar o estado intermédio quando prevê valores aproximados.
APPROX_TOP_K(expression, [number [counters]] Nota: se não for especificado nenhum parâmetro de número, a predefinição é 1. Os contadores devem ser significativamente superiores ao número.	APPROX_TOP_COUNT(expression, number) Nota: o BigQuery não suporta APPROX_TOP_COUNT com funções de janela.
APPROX_TOP_K_ACCUMULATE(expression, counters)	O BigQuery não suporta a capacidade de armazenar o estado intermédio quando prevê valores aproximados.
APPROX_TOP_K_COMBINE(state, [counters])	O BigQuery não suporta a capacidade de armazenar o estado intermédio quando prevê valores aproximados.
APPROX_TOP_K_ESTIMATE(state, [k])	O BigQuery não suporta a capacidade de armazenar o estado intermédio quando prevê valores aproximados.
APPROXIMATE_JACCARD_INDEX([DISTINCT] expression)	Pode usar uma FUD personalizada para implementar MINHASH com k funções hash distintas. Outra abordagem para reduzir a variância em MINHASH é manter k dos valores mínimos de uma função de hash. Neste caso, o índice de Jaccard pode ser aproximado da seguinte forma: 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)	É um sinónimo de APPROXIMATE_JACCARD_INDEX e pode ser implementado da mesma forma.
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: o BigQuery AVG não realiza a conversão automática em STRINGs.
BITAND_AGG(expression) [OVER ...]	BIT_AND(expression) [OVER ...] Nota: o BigQuery não converte implicitamente colunas de carateres/texto para o tipo INTEGER mais próximo.
BITOR_AGG(expression) [OVER ...]	BIT_OR(expression) [OVER ...] Nota: o BigQuery não converte implicitamente colunas de carateres/texto para o tipo INTEGER mais próximo.
BITXOR_AGG([DISTINCT] expression) [OVER ...]	BIT_XOR([DISTINCT] expression) [OVER ...] Nota: o BigQuery não converte implicitamente colunas de carateres/texto para o tipo INTEGER mais próximo.
BOOLAND_AGG(expression) [OVER ...] Nota: o Snowflake permite que os valores numéricos, decimais e de vírgula flutuante sejam tratados como TRUE se não forem zero.	LOGICAL_AND(expression) [OVER ...]
BOOLOR_AGG(expression) [OVER ...] Nota: o Snowflake permite que os valores numéricos, decimais e de vírgula flutuante sejam tratados como TRUE se não forem zero.	LOGICAL_OR(expression) [OVER ...]
BOOLXOR_AGG(expression) [OVER ([PARTITION BY <partition_expr> ]) Nota: o Snowflake permite que os valores numéricos, decimais e de vírgula flutuante sejam tratados como TRUE se não forem zero.	Para expressão numérica: SELECT CASE COUNT(*) WHEN 1 THEN TRUE WHEN 0 THEN NULL ELSE FALSE END AS BOOLXOR_AGG FROM T WHERE expression != 0 Para usar OVER, pode executar o seguinte (exemplo booleano fornecido): 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...])	O BigQuery não suporta uma alternativa direta à função GROUPING do Snowflake. Disponível através de uma função definida pelo utilizador.
GROUPING_ID(expression1, [,expression2...])	O BigQuery não suporta uma alternativa direta à função GROUPING_ID do Snowflake. Disponível através de uma função definida pelo utilizador.
HASH_AGG([DISTINCT] expression1, [,expression2]) [OVER ...]	SELECT BIT_XOR( FARM_FINGERPRINT( TO_JSON_STRING(t))) [OVER] FROM t
SELECT HLL([DISTINCT] expression1, [,expression2]) [OVER ...] Nota: o Snowflake não permite especificar a precisão.	SELECT HLL_COUNT.EXTRACT(sketch) FROM ( SELECT HLL_COUNT.INIT(expression) AS sketch FROM table ) Nota: o BigQuery não suporta HLL_COUNT… com funções de janela. Um utilizador não pode incluir várias expressões numa única função HLL_COUNT....
HLL_ACCUMULATE([DISTINCT] expression) Nota: o Snowflake não permite especificar a precisão.	HLL_COUNT.INIT(expression [, precision])
HLL_COMBINE([DISTINCT] state)	HLL_COUNT.MERGE_PARTIAL(esboço)
HLL_ESTIMATE(state)	HLL_COUNT.EXTRACT(sketch)
HLL_EXPORT(binary)	O BigQuery não suporta uma alternativa direta à função HLL_EXPORT do Snowflake.
HLL_IMPORT(object)	O BigQuery não suporta uma alternativa direta à função HLL_IMPORT do Snowflake.
KURTOSIS(expression) [OVER ...]	O BigQuery não suporta uma alternativa direta à função KURTOSIS do Snowflake.
LISTAGG( [DISTINCT] aggregate_expression [, delimiter] ) [OVER ...]	STRING_AGG( [DISTINCT] aggregate_expression [, delimiter] ) [OVER ...]
MEDIAN(expression) [OVER ...] Nota: o Snowflake não suporta a capacidade de IGNORE|RESPECT NULLS nem de LIMIT diretamente no ARRAY_AGG.	PERCENTILE_CONT( value_expression, 0.5 [ {RESPECT | IGNORE} NULLS] ) OVER()
MAX(expression) [OVER ...] MIN(expression) [OVER ...]	MAX(expression) [OVER ...] MIN(expression) [OVER ...]
MINHASH(k, [DISTINCT] expressions)	Pode usar uma FDU personalizada para implementar MINHASH com k funções hash distintas. Outra abordagem para reduzir a variância em MINHASH é manter k dos valores mínimos de uma função de hash: SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS MINHASH FROM t ORDER BY MINHASH LIMIT k
MINHASH_COMBINE([DISTINCT] state)	<code<select FROM ( SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS h FROM TA AS t ORDER BY h LIMIT k UNION SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS h FROM TB AS t ORDER BY h LIMIT k ) ORDER BY h LIMIT k
MODE(expr1) OVER ( [ PARTITION BY <expr2> ] )	SELECT expr1 FROM ( SELECT expr1, ROW_NUMBER() OVER ( PARTITION BY expr2 ORDER BY cnt DESC) rn FROM ( SELECT expr1, expr2, COUNTIF(expr1 IS NOT NULL) OVER (PARTITION BY expr2, expr1) cnt FROM t)) WHERE rn = 1
OBJECT_AGG(key, value) [OVER ...]	Pode ponderar usar TO_JSON_STRING para converter um valor numa string formatada em JSON
PERCENTILE_CONT(percentile) WITHIN GROUP (ORDER BY value_expression) [OVER ...]	PERCENTILE_CONT( value_expression, percentile [ {RESPECT | IGNORE} NULLS] ) OVER()
PERCENTILE_DISC(percentile) WITHIN GROUP (ORDER BY value_expression) [OVER ...]	PERCENTILE_DISC( value_expression, percentile [ {RESPECT | IGNORE} NULLS] ) OVER()
REGR_AVGX(dependent, independent) [OVER ...]	SELECT AVG(independent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) )
REGR_AVGY(dependent, independent) [OVER ...]	SELECT AVG(dependent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) )
REGR_COUNT(dependent, independent) [OVER ...]	SELECT COUNT(*) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) )
REGR_INTERCEPT(dependent, independent) [OVER ...]	SELECT AVG(dependent) - COVAR_POP(dependent,independent)/ VAR_POP(dependent) * AVG(independent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_R2(dependent, independent) [OVER ...]	SELECT CASE WHEN VAR_POP(independent) = 0 THEN NULL WHEN VAR_POP(dependent) = 0 AND VAR_POP(independent) != 0 THEN 1 ELSE POWER(CORR(dependent, independent), 2) END AS ... FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_SLOPE(dependent, independent) [OVER ...]	SELECT COVAR_POP(dependent,independent)/ VAR_POP(dependent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_SXX(dependent, independent) [OVER ...]	SELECT COUNT(*)*VAR_POP(independent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_SYY(dependent, independent) [OVER ...]	SELECT COUNT(*)*VAR_POP(dependent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
SKEW(expression)	O BigQuery não suporta uma alternativa direta ao SKEW do 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: o Snowflake suporta a capacidade de converter VARCHARs em valores de vírgula flutuante.	VAR_POP([DISTINCT] expression) [OVER ...]
VARIANCE_POP([DISTINCT] expression) [OVER ...] Nota: o Snowflake suporta a capacidade de converter VARCHARs em valores de vírgula flutuante.	VAR_POP([DISTINCT] expression) [OVER ...]
VAR_SAMP([DISTINCT] expression) [OVER ...] Nota: o Snowflake suporta a capacidade de converter VARCHARs em valores de vírgula flutuante.	VAR_SAMP([DISTINCT] expression) [OVER ...]
VARIANCE([DISTINCT] expression) [OVER ...] Nota: o Snowflake suporta a capacidade de converter VARCHARs em valores de vírgula flutuante.	VARIANCE([DISTINCT] expression) [OVER ...]

O BigQuery também oferece as seguintes funções de agregação, análise agregada e agregação aproximada, que não têm um análogo direto no Snowflake:

• COUNTIF
• ARRAY_CONCAT_AGG
• HLL_COUNT.MERGE

Funções de expressões bit a bit

A tabela seguinte mostra os mapeamentos entre as funções de expressão bit a bit comuns do Snowflake e os respetivos equivalentes no BigQuery.

Se o tipo de dados de uma expressão não for INTEGER, o Snowflake tenta converter para INTEGER. No entanto, o BigQuery não tenta converter para INTEGER.

Floco de neve	BigQuery
BITAND(expression1, expression2)	BIT_AND(x) FROM UNNEST([expression1, expression2]) AS x expression1 & expression2
BITNOT(expression)	~ expression
BITOR(expression1, expression2)	BIT_OR(x) FROM UNNEST([expression1, expression2]) AS x expression1 | expression2
BITSHIFTLEFT (expression, n)	expression << n
BITSHIFTRIGHT (expression, n)	expression >> n
BITXOR(expression, expression) Nota: o Snowflake não suporta DISTINCT.	BIT_XOR([DISTINCT] x) FROM UNNEST([expression1, expression2]) AS x expression ^ expression

Funções de expressão condicional

A tabela seguinte mostra mapeamentos entre expressões condicionais comuns do Snowflake e os respetivos equivalentes do BigQuery.

Floco de neve	BigQuery
expression [ NOT ] BETWEEN lower AND upper	(expression >= lower AND expression <= upper)
BOOLAND(expression1, expression2) Nota: o Snowflake permite que os valores numéricos, decimais e de vírgula flutuante sejam tratados como TRUE se não forem zero.	LOGICAL_AND(x) FROM UNNEST([expression1, expression2]) AS x expression1 AND expression2
BOOLNOT(expression1) Nota: o Snowflake permite que os valores numéricos, decimais e de vírgula flutuante sejam tratados como TRUE se não forem zero.	NOT expression
BOOLOR Nota: o Snowflake permite que os valores numéricos, decimais e de vírgula flutuante sejam tratados como TRUE se não forem zero.	LOGICAL_OR(x) FROM UNNEST([expression1, expression2]) AS x expression1 OR expression2
BOOLXOR Nota: o Snowflake permite que os valores numéricos, decimais e de vírgula flutuante sejam tratados como TRUE se não forem zero.	O BigQuery não suporta uma alternativa direta à função BOOLXOR.
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: o Snowflake requer, pelo menos, duas expressões. O BigQuery só requer um.	COALESCE(expr1, [,...])
DECODE(expression, search1, result1, [search2, result2...] [,default])	CASE [expression] WHEN condition1 THEN result1 [WHEN condition2 THEN result2] [...] [ELSE result3] END Nota: o BigQuery suporta subconsultas em declarações de condições. Pode usar esta opção para reproduzir o DECODE do Snowflake. O utilizador tem de usar IS NULL em vez de = NULL para fazer corresponder expressões de seleção NULL com expressões de pesquisa NULL.
EQUAL_NULL(expression1, expression2)	O BigQuery não suporta uma alternativa direta à função EQUAL_NULL.
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	O BigQuery não suporta uma alternativa direta à função IS [ NOT ] DISTINCT FROM.
expression IS [ NOT ] NULL	expression IS [ NOT ] NULL
IS_NULL_VALUE(variant_expr)	O BigQuery não suporta tipos de dados 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: o BigQuery não suporta uma alternativa direta às REGR... funções do Snowflake.
REGR_VALY(expr1,expr2)	IF(expr2 IS NULL, NULL, expr1) Nota: o BigQuery não suporta uma alternativa direta às REGR... funções do Snowflake.
ZEROIFNULL(expression)	IFNULL(expression,0)

Funções de contexto

A tabela seguinte mostra os mapeamentos entre funções de contexto comuns do Snowflake e os respetivos equivalentes do BigQuery.

Floco de neve	BigQuery
CURRENT_ACCOUNT()	SESSION_USER() Nota: não é uma comparação direta. O Snowflake devolve o ID da conta, enquanto o BigQuery devolve o endereço de email do utilizador.
CURRENT_CLIENT()	Conceito não usado no BigQuery
CURRENT_DATABASE()	SELECT catalog_name FROM INFORMATION_SCHEMA.SCHEMATA Isto devolve uma tabela de nomes de projetos. Não é uma comparação direta.
CURRENT_DATE[()] Nota: o Snowflake não aplica "()" após o comando CURRENT_DATE para agir em conformidade com as normas ANSI.	CURRENT_DATE([timezone]) Nota: o CURRENT_DATE do BigQuery suporta a especificação opcional do fuso horário.
CURRENT_REGION()	SELECT location FROM INFORMATION_SCHEMA.SCHEMATA Nota: a função INFORMATION_SCHEMA.SCHEMATA do BigQuery devolve referências de localização mais generalizadas do que a função CURRENT_REGION() do Snowflake. Não é uma comparação direta.
CURRENT_ROLE()	Conceito não usado no BigQuery
CURRENT_SCHEMA()	SELECT schema_name FROM INFORMATION_SCHEMA.SCHEMATA Isto devolve uma tabela de todos os conjuntos de dados (também denominados esquemas) disponíveis no projeto ou na região. Não é uma comparação direta.
CURRENT_SCHEMAS()	Conceito não usado no BigQuery
CURRENT_SESSION()	Conceito não usado no BigQuery
CURRENT_STATEMENT()	SELECT query FROM INFORMATION_SCHEMA.JOBS_BY_* Nota: o INFORMATION_SCHEMA.JOBS_BY_* do BigQuery permite pesquisar consultas por tipo de tarefa, tipo de início/fim, etc.
CURRENT_TIME[([frac_sec_prec])] Nota: o Snowflake permite uma precisão de segundos fracionada opcional. Os valores válidos variam entre 0 e 9 nanosegundos. O valor predefinido é 9. Para agir em conformidade com a ANSI, pode chamar esta função sem "()".	CURRENT_TIME()
CURRENT_TIMESTAMP[([frac_sec_prec])] Nota: o Snowflake permite uma precisão de segundos fracionada opcional. Os valores válidos variam entre 0 e 9 nanosegundos. O valor predefinido é 9. Para agir em conformidade com a ANSI, pode chamar esta função sem "()". Defina TIMEZONE como um parâmetro de sessão.	CURRENT_DATETIME([timezone]) CURRENT_TIMESTAMP() Nota: CURRENT_DATETIME devolve o tipo de dados DATETIME (não suportado no Snowflake). CURRENT_TIMESTAMP devolve o tipo de dados TIMESTAMP.
CURRENT_TRANSACTION()	SELECT job_id FROM INFORMATION_SCHEMA.JOBS_BY_* Nota: o INFORMATION_SCHEMA.JOBS_BY_* do BigQuery permite pesquisar IDs de tarefas por tipo de tarefa, tipo de início/fim, etc.
CURRENT_USER[()] Nota: o Snowflake não aplica "()" após o comando CURRENT_USER para agir em conformidade com as normas ANSI.	SESSION_USER() SELECT user_email FROM INFORMATION_SCHEMA.JOBS_BY_* Nota: não é uma comparação direta. O Snowflake devolve o nome de utilizador; o BigQuery devolve o endereço de email do utilizador.
CURRENT_VERSION()	Conceito não usado no BigQuery
CURRENT_WAREHOUSE()	SELECT catalg_name FROM INFORMATION_SCHEMA.SCHEMATA
LAST_QUERY_ID([num])	SELECT job_id FROM INFORMATION_SCHEMA.JOBS_BY_* Nota: o INFORMATION_SCHEMA.JOBS_BY_* do BigQuery permite pesquisar IDs de tarefas por tipo de tarefa, tipo de início/fim, etc.
LAST_TRANSACTION()	SELECT job_id FROM INFORMATION_SCHEMA.JOBS_BY_* Nota: o INFORMATION_SCHEMA.JOBS_BY_* do BigQuery permite pesquisar IDs de tarefas por tipo de tarefa, tipo de início/fim, etc.
LOCALTIME() Nota: o Snowflake não aplica "()" após o comando LOCALTIME para agir em conformidade com as normas ANSI.	CURRENT_TIME()
LOCALTIMESTAMP()	CURRENT_DATETIME([timezone]) CURRENT_TIMESTAMP() Nota: CURRENT_DATETIME devolve o tipo de dados DATETIME (não suportado no Snowflake). CURRENT_TIMESTAMP devolve o tipo de dados TIMESTAMP.

Funções de conversão

A tabela seguinte mostra os mapeamentos entre funções de conversão comuns do Snowflake e os respetivos equivalentes no BigQuery.

Tenha em atenção que as funções que parecem idênticas no Snowflake e no BigQuery podem devolver tipos de dados diferentes.

Snowflake	BigQuery
CAST(expression AS type) expression :: type	CAST(expression AS type)
TO_ARRAY(expression)	[expression] ARRAY(subquery)
TO_BINARY(expression[, format]) Nota: o Snowflake suporta a conversão HEX, BASE64 e UTF-8. O Snowflake também suporta TO_BINARY através do tipo de dados VARIANT. O BigQuery não tem uma alternativa ao tipo de dados VARIANT.	TO_HEX(CAST(expression AS BYTES)) TO_BASE64(CAST(expression AS BYTES)) CAST(expression AS BYTES) Nota: a conversão STRING predefinida do BigQuery usa a codificação UTF-8. O Snowflake não tem uma opção para suportar a codificação BASE32.
TO_BOOLEAN(expression) Nota: INT64 TRUE: caso contrário, FALSE: 0 STRING TRUE: "true"/"t"/"yes"/"y"/"on"/"1", FALSE: "false"/"f"/"no"/"n"/"off"/"0"	CAST(expression AS BOOL) Nota: INT64 TRUE: caso contrário, FALSE: 0 STRING TRUE: "true", FALSE: "false"
TO_CHAR(expression[, format]) TO_VARCHAR(expression[, format]) Nota: pode encontrar os modelos de formato do Snowflake aqui. O BigQuery não tem uma alternativa ao tipo de dados VARIANT.	CAST(expression AS STRING) Nota: a expressão de entrada do BigQuery pode ser formatada com FORMAT_DATE, FORMAT_DATETIME, FORMAT_TIME ou FORMAT_TIMESTAMP.
TO_DATE(expression[, format]) DATE(expression[, format]) Nota: o Snowflake suporta a capacidade de converter diretamente tipos INTEGER em tipos DATE. Pode encontrar os modelos de formato da Snowflake aqui. O BigQuery não tem uma alternativa ao tipo de dados VARIANT.	CAST(expression AS DATE) Nota: a expressão de entrada do BigQuery pode ser formatada com FORMAT, FORMAT_DATETIME ou FORMAT_TIMESTAMP.
TO_DECIMAL(expression[, format] [,precision[, scale]] TO_NUMBER(expression[, format] [,precision[, scale]] TO_NUMERIC(expression[, format] [,precision[, scale]] Nota: pode encontrar os modelos de formato do Snowflake para os tipos de dados DECIMAL, NUMBER e NUMERIC aqui. O BigQuery não tem uma alternativa ao tipo de dados VARIANT.	ROUND(CAST(expression AS NUMERIC) , x) Nota: a expressão de entrada do BigQuery pode ser formatada através de FORMAT.
TO_DOUBLE(expression[, format]) Nota: pode encontrar os modelos de formato do Snowflake para os DOUBLE tipos de dados aqui. O BigQuery não tem uma alternativa ao tipo de dados VARIANT.	CAST(expression AS FLOAT64) Nota: a expressão de entrada do BigQuery pode ser formatada através de FORMAT.
TO_JSON(variant_expression)	O BigQuery não tem uma alternativa ao tipo de dados VARIANT do Snowflake.
TO_OBJECT(variant_expression)	O BigQuery não tem uma alternativa ao tipo de dados VARIANT do Snowflake.
TO_TIME(expression[, format]) TIME(expression[, format]) Nota: pode encontrar os modelos de formato do Snowflake para os STRING tipos de dados aqui. O BigQuery não tem uma alternativa ao tipo de dados VARIANT.	CAST(expression AS TIME) Nota: o BigQuery não tem uma alternativa ao tipo de dados VARIANT do Snowflake. A expressão de entrada do BigQuery pode ser formatada com FORMAT, FORMAT_DATETIME, FORMAT_TIMESTAMP ou FORMAT_TIME.
TO_TIMESTAMP(expression[, scale]) TO_TIMESTAMP_LTZ(expression[, scale]) TO_TIMESTAMP_NTZ(expression[, scale]) TO_TIMESTAMP_TZ(expression[, scale]) Nota: o BigQuery não tem uma alternativa ao tipo de dados VARIANT.	CAST(expression AS TIMESTAMP) Nota: a expressão de entrada do BigQuery pode ser formatada com FORMAT, FORMAT_DATE, FORMAT_DATETIME e FORMAT_TIME. O fuso horário pode ser incluído/não incluído através de parâmetros FORMAT_TIMESTAMP.
TO_VARIANT(expression)	O BigQuery não tem uma alternativa ao tipo de dados VARIANT do Snowflake.
TO_XML(variant_expression)	O BigQuery não tem uma alternativa ao tipo de dados VARIANT do 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)

O BigQuery também oferece as seguintes funções de conversão, que não têm um análogo direto no 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

Funções de geração de dados

A tabela seguinte mostra mapeamentos entre funções comuns de geração de dados do Snowflake e os respetivos equivalentes no BigQuery.

Snowflake	BigQuery
NORMAL(mean, stddev, gen)	O BigQuery não suporta uma comparação direta com a função NORMAL.
RANDOM([seed])	IF(RAND()>0.5, CAST(RAND()*POW(10, 18) AS INT64), (-1)*CAST(RAND()*POW(10, 18) AS INT64)) Nota: o BigQuery não suporta a inicialização
RANDSTR(length, gen)	O BigQuery não suporta uma comparação direta com a função RANDSTR.
SEQ1 / SEQ2 / SEQ4 / SEQ8	O BigQuery não suporta uma comparação direta com a função SEQ_.
UNIFORM(min, max, gen)	CAST(min + RAND()*(max-min) AS INT64) Nota:use UDFs persistentes para criar um equivalente à função UNIFORM do Snowflake. Exemplo aqui.
UUID_STRING([uuid, name]) Nota: o Snowflake devolve 128 bits aleatórios. O Snowflake suporta UUIDs da versão 4 (aleatórios) e da versão 5 (denominados).	GENERATE_UUID() Nota: o BigQuery devolve 122 bits aleatórios. O BigQuery só suporta UUIDs da versão 4.
ZIPF(s, N, gen)	O BigQuery não suporta uma comparação direta com a função ZIPF.

Funções de data e hora

A tabela seguinte mostra mapeamentos entre funções comuns de data e hora do Snowflake com os respetivos equivalentes no BigQuery. As funções de data e hora do BigQuery incluem funções de data, funções de data/hora, funções de hora e funções de data/hora.

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 no BigQuery
DATE_FROM_PARTS(year, month, day) Nota: o Snowflake suporta datas negativas e de overflow. Por exemplo, DATE_FROM_PARTS(2000, 1 + 24, 1) devolve 1 de janeiro de 2002. Isto não é suportado no BigQuery.	DATE(year, month, day) DATE(timestamp_expression[, timezone]) DATE(datetime_expression)
DATE_PART(part, dateOrTime) Nota: o Snowflake suporta os tipos de partes ISO do dia da semana, nanosegundo e segundo/milissegundo/microssegundo/nanosegundo da época. O BigQuery não. Consulte a lista completa de tipos de peças do Snowflake aqui.	EXTRACT(part FROM dateOrTime) Nota: o BigQuery suporta os tipos de partes week(<weekday>), microsecond e millisecond. O Snowflake não o faz. Veja a lista completa de tipos de partições do BigQuery aqui e aqui.
DATE_TRUNC(part, dateOrTime) Nota: o Snowflake suporta o tipo de parte de nanosegundos. O BigQuery não. Consulte a lista completa de tipos de peças do Snowflake aqui.	DATE_TRUNC(date, part) DATETIME_TRUNC(datetime, part) TIME_TRUNC(time, part) TIMESTAMP_TRUNC(timestamp, part[, timezone]) Nota: o BigQuery suporta os tipos de partes de semana(<weekday>), semana ISO e ano ISO. O Snowflake não o faz.
DATEADD(part, value, dateOrTime)	DATE_ADD(date, INTERVAL value part)
DATEDIFF( part, start_date_or_time, end_date_or_time ) Nota: o Snowflake suporta o cálculo da diferença entre dois tipos de data, hora e data/hora nesta função.	DATE_DIFF( end_date, start_date, part ) DATETIME_DIFF( end_datetime, start_datetime, part ) TIME_DIFF( start_time, end_time, part ) TIMESTAMP_DIFF( end_timestamp, start_timestamp, part ) Nota: o BigQuery suporta os tipos de partes de ano ISO e semana(<weekday>).
DAYNAME(dateOrTimestamp)	FORMAT_DATE('%a', date) FORMAT_DATETIME('%a', datetime) FORMAT_TIMESTAMP('%a', timestamp)
EXTRACT(part FROM dateOrTime) Nota: o Snowflake suporta os tipos de partes ISO do dia da semana, nanosegundo e segundo/milissegundo/microssegundo/nanosegundo da época. O BigQuery não. Consulte a lista completa de tipos de peças do Snowflake aqui.	EXTRACT(part FROM dateOrTime) Nota: o BigQuery suporta os tipos de partes week(<weekday>), microsecond e millisecond. O Snowflake não o faz. Veja a lista completa de tipos de partições do BigQuery aqui e aqui.
[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: pode ser necessário reformatar dowString. Por exemplo, "su" no Snowflake torna-se "SUNDAY" no BigQuery.
PREVIOUS_DAY(dateOrTime, dowString)	DATE_TRUNC( date, WEEK(dowString) ) Nota: pode ser necessário reformatar dowString. Por exemplo, "su" no Snowflake torna-se "SUNDAY" no BigQuery.
TIME_FROM_PARTS(hour, minute, second[, nanosecond) Nota: o Snowflake suporta tempos de overflow. Por exemplo, TIME_FROM_PARTS(0, 100, 0) devolve 01:40:00... Isto não é suportado no BigQuery. O BigQuery não suporta nanosegundos.	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: o BigQuery não suporta uma comparação direta e exata com o TIME_SLICE do Snowflake. Use DATETINE_TRUNC, TIME_TRUNC, TIMESTAMP_TRUNC para o tipo de dados adequado.
TIMEADD(part, value, dateOrTime)	TIME_ADD(time, INTERVAL value part)
TIMEDIFF( part, expression1, expression2, ) Nota: o Snowflake suporta o cálculo da diferença entre dois tipos de data, hora e data/hora nesta função.	DATE_DIFF( dateExpression1, dateExpression2, part ) DATETIME_DIFF( datetimeExpression1, datetimeExpression2, part ) TIME_DIFF( timeExpression1, timeExpression2, part ) TIMESTAMP_DIFF( timestampExpression1, timestampExpression2, part ) Nota: o BigQuery suporta os tipos de partes de ano ISO e semana(<weekday>).
TIMESTAMP_[LTZ, NTZ, TZ _]FROM_PARTS (year, month, day, hour, second [, nanosecond][, timezone])	TIMESTAMP( string_expression[, timezone] | date_expression[, timezone] | datetime_expression[, timezone] ) Nota: o BigQuery requer que as datas/horas sejam introduzidas como tipos STRING. Exemplo: "2008-12-25 15:30:00"
TIMESTAMPADD(part, value, dateOrTime)	TIMESTAMPADD(timestamp, INTERVAL value part)
TIMESTAMPDIFF( part, expression1, expression2, ) Nota: o Snowflake suporta o cálculo da diferença entre dois tipos de data, hora e data/hora nesta função.	DATE_DIFF( dateExpression1, dateExpression2, part ) DATETIME_DIFF( datetimeExpression1, datetimeExpression2, part ) TIME_DIFF( timeExpression1, timeExpression2, part ) TIMESTAMP_DIFF( timestampExpression1, timestampExpression2, part ) Nota: o BigQuery suporta os tipos de partes de ano ISO e semana(<weekday>).
TRUNC(dateOrTime, part) Nota: o Snowflake suporta o tipo de parte de nanosegundos. O BigQuery não. Consulte a lista completa de tipos de peças do Snowflake aqui.	DATE_TRUNC(date, part) DATETIME_TRUNC(datetime, part) TIME_TRUNC(time, part) TIMESTAMP_TRUNC(timestamp, part[, timezone]) Nota: o BigQuery suporta os tipos de partes de semana(<weekday>), semana ISO e ano ISO. O Snowflake não o faz.
[YEAR*, DAY*, WEEK*, MONTH, QUARTER](dateOrTimestamp)	EXTRACT(part FROM timestamp [AT THE ZONE timezone])

O BigQuery também oferece as seguintes funções de data e hora, que não têm um análogo direto no 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

Esquema de informações e funções de tabela

O BigQuery não suporta conceptualmente muitas das funções de esquema de informações e de tabelas do Snowflake. O Snowflake oferece o seguinte esquema de informações e funções de tabela, que não têm um análogo direto no 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

Segue-se uma lista de funções de tabela e de esquema de informações do BigQuery e do Snowflake associadas.

Snowflake	BigQuery
QUERY_HISTORY QUERY_HISTORY_BY_*	INFORMATION_SCHEMA.JOBS_BY_* Nota: não é uma alternativa direta.
TASK_HISTORY	INFORMATION_SCHEMA.JOBS_BY_* Nota: não é uma alternativa direta.

O BigQuery oferece o seguinte esquema de informações e funções de tabela, que não têm um análogo direto no Snowflake:

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

Funções numéricas

A tabela seguinte mostra os mapeamentos entre as funções numéricas comuns do Snowflake e os respetivos equivalentes no 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: o CEIL do BigQuery não suporta a capacidade de indicar a precisão ou a escala. ROUND não lhe permite especificar o arredondamento para cima.
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)	O BigQuery não tem uma alternativa direta para o FACTORIAL do Snowflake. Usar uma função definida pelo utilizador.
FLOOR(expression [, scale])	FLOOR(expression) Nota: o FLOOR do BigQuery não suporta a capacidade de indicar a precisão ou a escala. ROUND não lhe permite especificar o arredondamento para cima. TRUNC funciona de forma sinónima para números positivos, mas não para números negativos, uma vez que avalia o valor absoluto.
HAVERSINE(lat1, lon1, lat2, lon2)	ST_DISTANCE( ST_GEOGPOINT(lon1, lat1), ST_GEOGPOINT(lon2, lat2) )/1000 Nota: não é uma correspondência exata, mas é suficientemente próxima.
LN(expression)	LN(expression)
LOG(base, expression)	LOG(expression [,base]) LOG10(expression) Nota:a base predefinida para 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: o valor devolvido do BigQuery tem de ser inferior à expressão. Não suporta igual a.

O BigQuery também oferece as seguintes funções matemáticas, que não têm um análogo direto no Snowflake:

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

Funções de dados semiestruturados

Snowflake	BigQuery
ARRAY_APPEND	Função definida pelo utilizador personalizada
ARRAY_CAT	ARRAY_CONCAT
ARRAY_COMPACT	Função definida pelo utilizador personalizada
ARRAY_CONSTRUCT	[ ]
ARRAY_CONSTRUCT_COMPACT	Função definida pelo utilizador personalizada
ARRAY_CONTAINS	Função definida pelo utilizador personalizada
ARRAY_INSERT	Função definida pelo utilizador personalizada
ARRAY_INTERSECTION	Função definida pelo utilizador personalizada
ARRAY_POSITION	Função definida pelo utilizador personalizada
ARRAY_PREPEND	Função definida pelo utilizador personalizada
ARRAY_SIZE	ARRAY_LENGTH
ARRAY_SLICE	Função definida pelo utilizador personalizada
ARRAY_TO_STRING	ARRAY_TO_STRING
ARRAYS_OVERLAP	Função definida pelo utilizador personalizada
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	Função definida pelo utilizador personalizada
CHECK_XML	Função definida pelo utilizador personalizada
FLATTEN	UNNEST
GET	Função definida pelo utilizador personalizada
GET_IGNORE_CASE	Função definida pelo utilizador personalizada
GET_PATH , :	Função definida pelo utilizador personalizada
IS_<object_type>	Função definida pelo utilizador personalizada
IS_ARRAY	Função definida pelo utilizador personalizada
IS_BINARY	Função definida pelo utilizador personalizada
IS_BOOLEAN	Função definida pelo utilizador personalizada
IS_CHAR , IS_VARCHAR	Função definida pelo utilizador personalizada
IS_DATE , IS_DATE_VALUE	Função definida pelo utilizador personalizada
IS_DECIMAL	Função definida pelo utilizador personalizada
IS_DOUBLE , IS_REAL	Função definida pelo utilizador personalizada
IS_INTEGER	Função definida pelo utilizador personalizada
IS_OBJECT	Função definida pelo utilizador personalizada
IS_TIME	Função definida pelo utilizador personalizada
IS_TIMESTAMP_*	Função definida pelo utilizador personalizada
OBJECT_CONSTRUCT	Função definida pelo utilizador personalizada
OBJECT_DELETE	Função definida pelo utilizador personalizada
OBJECT_INSERT	Função definida pelo utilizador personalizada
PARSE_JSON	JSON_EXTRACT
PARSE_XML	Função definida pelo utilizador personalizada
STRIP_NULL_VALUE	Função definida pelo utilizador personalizada
STRTOK_TO_ARRAY	SPLIT
TRY_PARSE_JSON	Função definida pelo utilizador personalizada
TYPEOF	Função definida pelo utilizador personalizada
XMLGET	Função definida pelo utilizador personalizada

Funções de string e binárias

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	Função definida pelo utilizador personalizada
COLLATION	Função definida pelo utilizador personalizada
COMPRESS	Função definida pelo utilizador personalizada
CONCAT(string1, string2)	CONCAT(string1, string2) Nota: a função CONCAT(...) do BigQuery suporta a concatenação de qualquer número de strings.
CONTAINS	Função definida pelo utilizador personalizada
DECOMPRESS_BINARY	Função definida pelo utilizador personalizada
DECOMPRESS_STRING	Função definida pelo utilizador personalizada
EDITDISTANCE	EDIT_DISTANCE
ENDSWITH	Função definida pelo utilizador personalizada
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	Função definida pelo utilizador personalizada
ILIKE ANY	Função definida pelo utilizador personalizada
INITCAP	INITCAP
INSERT	Função definida pelo utilizador personalizada
LEFT	Função definida pelo utilizador
LENGTH	LENGTH(expression)
LIKE	LIKE
LIKE ALL	Função definida pelo utilizador personalizada
LIKE ANY	Função definida pelo utilizador personalizada
LOWER	LOWER(string)
LPAD	LPAD(string1, length[, string2])
LTRIM	LTRIM(string1, trim_chars)
MD5,MD5_HEX	MD5(string)
MD5_BINARY	Função definida pelo utilizador personalizada
OCTET_LENGTH	Função definida pelo utilizador personalizada
PARSE_IP	Função definida pelo utilizador personalizada
PARSE_URL	Função definida pelo utilizador personalizada
POSITION	STRPOS(string, substring)
REPEAT	REPEAT(string, integer)
REPLACE	REPLACE(string1, old_chars, new_chars)
REVERSE number_characters )	REVERSE(expression)
RIGHT	Função definida pelo utilizador
RPAD	RPAD
RTRIM	RTRIM(string, trim_chars)
RTRIMMED_LENGTH	Função definida pelo utilizador personalizada
SHA1,SHA1_HEX	SHA1(string)
SHA1_BINARY	Função definida pelo utilizador personalizada
SHA2,SHA2_HEX	Função definida pelo utilizador personalizada
SHA2_BINARY	Função definida pelo utilizador personalizada
SOUNDEX	Função definida pelo utilizador personalizada
SPACE	Função definida pelo utilizador personalizada
SPLIT	SPLIT
SPLIT_PART	Função definida pelo utilizador personalizada
SPLIT_TO_TABLE	Função definida pelo utilizador personalizada
STARTSWITH	Função definida pelo utilizador personalizada
STRTOK	SPLIT(instring, delimiter)[ORDINAL(tokennum)] Nota: o argumento de string delimitador completo é usado como um único delimitador. O delimitador predefinido é uma vírgula.
STRTOK_SPLIT_TO_TABLE	Função definida pelo utilizador personalizada
SUBSTR,SUBSTRING	SUBSTR
TRANSLATE	Função definida pelo utilizador personalizada
TRIM	TRIM
TRY_BASE64_DECODE_BINARY	Função definida pelo utilizador personalizada
TRY_BASE64_DECODE_STRING	SUBSTR(string, 0, integer)
TRY_HEX_DECODE_BINARY	SUBSTR(string, -integer)
TRY_HEX_DECODE_STRING	LENGTH(expression)
UNICODE	Função definida pelo utilizador personalizada
UPPER	UPPER

Funções de string (expressões regulares)

Snowflake	BigQuery
REGEXP	IF(REGEXP_CONTAINS,1,0)=1
REGEXP_COUNT	ARRAY_LENGTH( REGEXP_EXTRACT_ALL( source_string, pattern ) ) Se position estiver especificado: ARRAY_LENGTH( REGEXP_EXTRACT_ALL( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern ) ) Nota: o BigQuery oferece suporte para expressões regulares através da biblioteca re2. Consulte a documentação da biblioteca para ver a respetiva sintaxe de expressões regulares.
REGEXP_INSTR	IFNULL( STRPOS( source_string, REGEXP_EXTRACT( source_string, pattern) ), 0) Se position for especificado: 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 estiver especificado: 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: o BigQuery oferece suporte para expressões regulares através da biblioteca re2. Consulte a documentação da biblioteca para ver a respetiva sintaxe de expressões regulares.
REGEXP_LIKE	IF(REGEXP_CONTAINS,1,0)=1
REGEXP_REPLACE	REGEXP_REPLACE( source_string, pattern, "" ) Se replace_string estiver especificado: REGEXP_REPLACE( source_string, pattern, replace_string ) Se position estiver especificado: 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: o BigQuery oferece suporte para expressões regulares através da biblioteca re2. Consulte a documentação da biblioteca para ver a respetiva sintaxe de expressões regulares.
REGEXP_SUBSTR	REGEXP_EXTRACT( source_string, pattern ) Se position estiver especificado: REGEXP_EXTRACT( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern ) Se occurrence estiver especificado: REGEXP_EXTRACT_ALL( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern )[SAFE_ORDINAL(occurrence)] Nota: o BigQuery oferece suporte para expressões regulares através da biblioteca re2. Consulte a documentação da biblioteca para ver a respetiva sintaxe de expressões regulares.
RLIKE	IF(REGEXP_CONTAINS,1,0)=1

Funções do sistema

Snowflake	BigQuery
SYSTEM$ABORT_SESSION	Função definida pelo utilizador personalizada
SYSTEM$ABORT_TRANSACTION	Função definida pelo utilizador personalizada
SYSTEM$CANCEL_ALL_QUERIES	Função definida pelo utilizador personalizada
SYSTEM$CANCEL_QUERY	Função definida pelo utilizador personalizada
SYSTEM$CLUSTERING_DEPTH	Função definida pelo utilizador personalizada
SYSTEM$CLUSTERING_INFORMATION	Função definida pelo utilizador personalizada
SYSTEM$CLUSTERING_RATIO — Deprecated	Função definida pelo utilizador personalizada
SYSTEM$CURRENT_USER_TASK_NAME	Função definida pelo utilizador personalizada
SYSTEM$DATABASE_REFRESH_HISTORY	Função definida pelo utilizador personalizada
SYSTEM$DATABASE_REFRESH_PROGRESS , SYSTEM$DATABASE_REFRESH_PROGRESS_BY_JOB	Função definida pelo utilizador personalizada
SYSTEM$GET_AWS_SNS_IAM_POLICY	Função definida pelo utilizador personalizada
SYSTEM$GET_PREDECESSOR_RETURN_VALUE	Função definida pelo utilizador personalizada
SYSTEM$LAST_CHANGE_COMMIT_TIME	Função definida pelo utilizador personalizada
SYSTEM$PIPE_FORCE_RESUME	Função definida pelo utilizador personalizada
SYSTEM$PIPE_STATUS	Função definida pelo utilizador personalizada
SYSTEM$SET_RETURN_VALUE	Função definida pelo utilizador personalizada
SYSTEM$SHOW_OAUTH_CLIENT_SECRETS	Função definida pelo utilizador personalizada
SYSTEM$STREAM_GET_TABLE_TIMESTAMP	Função definida pelo utilizador personalizada
SYSTEM$STREAM_HAS_DATA	Função definida pelo utilizador personalizada
SYSTEM$TASK_DEPENDENTS_ENABLE	Função definida pelo utilizador personalizada
SYSTEM$TYPEOF	Função definida pelo utilizador personalizada
SYSTEM$USER_TASK_CANCEL_ONGOING_EXECUTIONS	Função definida pelo utilizador personalizada
SYSTEM$WAIT	Função definida pelo utilizador personalizada
SYSTEM$WHITELIST	Função definida pelo utilizador personalizada
SYSTEM$WHITELIST_PRIVATELINK	Função definida pelo utilizador personalizada

Funções de tabela

Snowflake		BigQuery
GENERATOR		Função definida pelo utilizador personalizada
GET_OBJECT_REFERENCES		Função definida pelo utilizador personalizada
RESULT_SCAN		Função definida pelo utilizador personalizada
VALIDATE		Função definida pelo utilizador personalizada

Funções utilitárias e hash

Snowflake		BigQuery
GET_DDL		Pedido de funcionalidade
HASH		HASH é uma função proprietária específica do Snowflake. Não é possível traduzir sem conhecer a lógica subjacente usada pelo Snowflake.

Funções de janela

Snowflake		BigQuery
CONDITIONAL_CHANGE_EVENT		Função definida pelo utilizador personalizada
CONDITIONAL_TRUE_EVENT		Função definida pelo utilizador personalizada
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		Função definida pelo utilizador personalizada
ROW_NUMBER		ROW_NUMBER
WIDTH_BUCKET		Função definida pelo utilizador personalizada

O BigQuery também suporta SAFE_CAST(expression AS typename), que devolve NULL se o BigQuery não conseguir executar um molde (por exemplo, SAFE_CAST("apple" AS INT64) devolve NULL).

Operadores

As secções seguintes apresentam os operadores do Snowflake e os respetivos equivalentes no BigQuery.

Operadores aritméticos

A tabela seguinte mostra os mapeamentos entre os operadores aritméticos do Snowflake com os respetivos equivalentes no BigQuery.

Snowflake	BigQuery
(Unary) (+'5')	CAST("5" AS NUMERIC)
a + b	a + b
(Unary) (-'5')	(-1) * CAST("5" AS NUMERIC) Nota: o BigQuery suporta o sinal de menos unário padrão, mas não converte números inteiros no formato de string para o tipo INT64, NUMERIC ou 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)

Para ver os detalhes da escala e da precisão do Snowflake quando realizar operações aritméticas, consulte a documentação do Snowflake.

Operadores de comparação

Os operadores de comparação do Snowflake e os operadores de comparação do BigQuery são iguais.

Operadores lógicos/booleanos

Os operadores lógicos/booleanos do Snowflake e os operadores lógicos/booleanos do BigQuery são iguais.

Operadores de conjuntos

A tabela seguinte mostra mapeamentos entre os operadores de conjuntos do Snowflake e os respetivos equivalentes no BigQuery.

Snowflake	BigQuery
SELECT ... INTERSECT SELECT ...	SELECT ... INTERSECT DISTINCT SELECT...
SELECT ... MINUS SELECT ... SELECT ... EXCEPT SELECT … Nota: MINUS e EXCEPT são sinónimos.	SELECT ... EXCEPT DISTINCT SELECT ...
SELECT ... UNION SELECT ... SELECT ... UNION ALL SELECT ...	SELECT ... UNION DISTINCT SELECT ... SELECT ... UNION ALL SELECT ...

Operadores de subconsulta

A tabela seguinte mostra os mapeamentos entre os operadores de subconsulta do Snowflake e os respetivos equivalentes no BigQuery.

Snowflake	BigQuery
SELECT ... FROM ... WHERE col <operator> ALL … SELECT ... FROM ... WHERE col <operator> ANY ...	O BigQuery não suporta uma alternativa direta ao ALL/ANY do 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: o BigQuery requer parênteses para separar diferentes operações de conjuntos. Se o mesmo operador de conjunto for repetido, os parênteses não são necessários.

Sintaxe DML

Esta secção aborda as diferenças na sintaxe da linguagem de gestão de dados entre o Snowflake e o BigQuery.

INSERT declaração

O Snowflake oferece uma palavra-chave DEFAULT configurável para colunas. No BigQuery, o valor DEFAULT para colunas anuláveis é NULL e DEFAULT não é suportado para colunas obrigatórias. A maioria das declarações do Snowflake são compatíveis com o BigQuery.INSERT A tabela seguinte mostra as exceções.

Snowflake	BigQuery
INSERT [OVERWRITE] INTO table VALUES [... | DEFAULT | NULL] ... Nota: o BigQuery não suporta a inserção de objetos JSON com uma INSERT declaração.	INSERT [INTO] table (column1 [, ...]) VALUES (DEFAULT [, ...]) Nota: o BigQuery não suporta uma alternativa direta à função OVERWRITE do Snowflake. Em alternativa, use 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> representa o INSERT statement padrão, indicado acima.	O BigQuery não suporta INSERTs de várias tabelas condicionais e incondicionais.

O BigQuery também suporta a inserção de valores através de uma subconsulta (em que um dos valores é calculado através de uma subconsulta), o que não é suportado no Snowflake. Por exemplo:

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

COPY declaração

O Snowflake suporta a cópia de dados de ficheiros de fases para uma tabela existente e de uma tabela para uma fase interna com nome, uma fase externa com nome e uma localização externa (Amazon S3, Google Cloud Storage ou Microsoft Azure).

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

O BigQuery não usa o comando SQL COPY para carregar dados, mas pode usar qualquer uma das várias ferramentas e opções não SQL para carregar dados em tabelas do BigQuery. Também pode usar destinos de pipelines de dados fornecidos no Apache Spark ou no Apache Beam para escrever dados no BigQuery.

UPDATE declaração

A maioria das declarações do Snowflake UPDATE é compatível com o BigQuery. A tabela seguinte mostra as exceções.

Snowflake		BigQuery
UPDATE table SET col = value [,...] [FROM ...] [WHERE ...]		UPDATE table SET column = expression [,...] [FROM ...] WHERE TRUE Nota: todas as declarações UPDATE no BigQuery requerem uma palavra-chave WHERE, seguida de uma condição.

DELETE e TRUNCATE TABLE extratos

As declarações DELETE e TRUNCATE TABLE são ambas formas de remover linhas de uma tabela sem afetar o esquema ou os índices da tabela.

No Snowflake, tanto o DELETE como o TRUNCATE TABLE mantêm os dados eliminados através da funcionalidade Time Travel do Snowflake para fins de recuperação durante o período de retenção de dados. No entanto, o comando DELETE não elimina o histórico de carregamento de ficheiros externos nem os metadados de carregamento.

No BigQuery, a declaração DELETE tem de ter uma cláusula WHERE. Para mais informações sobre DELETE no BigQuery, consulte os exemplos do BigQueryDELETE na documentação da DML.

Snowflake	BigQuery
DELETE FROM table_name [USING ...] [WHERE ...] TRUNCATE [TABLE] [IF EXISTS] table_name	DELETE [FROM] table_name [alias] WHERE ... Nota: as declarações do BigQuery DELETE requerem uma cláusula WHERE .

MERGE declaração

A declaração MERGE pode combinar operações INSERT, UPDATE e DELETE numa única declaração "upsert" e realizar as operações automaticamente. A operação MERGE tem de corresponder, no máximo, a uma linha de origem para cada linha de destino.

As tabelas do BigQuery estão limitadas a 1000 declarações DML por dia, pelo que deve consolidar de forma ideal as declarações INSERT, UPDATE e DELETE numa única declaração MERGE, conforme mostrado na tabela seguinte:

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: o Snowflake suporta um parâmetro de sessão ERROR_ON_NONDETERMINISTIC_MERGE para processar resultados não determinísticos.	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 atualizar todas as colunas, tem de as indicar todas.

GET e LIST extratos

A declaração GET transfere ficheiros de dados de um dos seguintes estágios do Snowflake para um diretório/pasta local num computador cliente:

• Fase interna com nome
• Fase interna de uma tabela especificada
• Fase interna para o utilizador atual

A declaração LIST (LS) devolve uma lista de ficheiros que foram preparados (ou seja, carregados a partir de um sistema de ficheiros local ou descarregados de uma tabela) numa das seguintes preparações do Snowflake:

• Fase interna com nome
• Palco externo com nome
• Preparação para uma tabela especificada
• Fase para o utilizador atual

O BigQuery não suporta o conceito de preparação e não tem equivalentes de GET e LIST.

PUT e REMOVE extratos

A declaração PUT carrega (ou seja, prepara) ficheiros de dados de um diretório/pasta local num computador cliente para uma das seguintes preparações do Snowflake:

• Fase interna com nome
• Fase interna de uma tabela especificada
• Fase interna para o utilizador atual

A declaração REMOVE (RM) remove ficheiros que foram preparados numa das seguintes fases internas do Snowflake:

• Fase interna com nome
• Preparação para uma tabela especificada
• Fase para o utilizador atual

O BigQuery não suporta o conceito de preparação e não tem equivalentes de PUT e REMOVE.

Sintaxe DDL

Esta secção aborda as diferenças na sintaxe da linguagem de definição de dados entre o Snowflake e o BigQuery.

LDD de base de dados, esquema e partilha

A maioria da terminologia do Snowflake corresponde à do BigQuery, exceto que a base de dados do Snowflake é semelhante ao conjunto de dados do BigQuery. Consulte o mapeamento detalhado da terminologia do Snowflake para o BigQuery.

CREATE DATABASE declaração

O Snowflake suporta a criação e a gestão de uma base de dados através de comandos de gestão de bases de dados , enquanto o BigQuery oferece várias opções, como a utilização da consola, da CLI, das bibliotecas de cliente, etc., para criar conjuntos de dados. Esta secção vai usar comandos da CLI do BigQuery correspondentes aos comandos do Snowflake para abordar as diferenças.

Snowflake	BigQuery
CREATE DATABASE <name> Nota: o Snowflake fornece estes requisitos para a atribuição de nomes a bases de dados. Permite apenas 255 carateres no nome.	bq mk <name> Nota: o BigQuery tem requisitos de nomenclatura de conjuntos de dados semelhantes aos do Snowflake, exceto que permite 1024 carateres no nome.
CREATE OR REPLACE DATABASE <name>	A substituição do conjunto de dados não é suportada no BigQuery.
CREATE TRANSIENT DATABASE <name>	A criação de conjuntos de dados temporários não é suportada no BigQuery.
CREATE DATABASE IF NOT EXISTS <name>	Conceito não suportado no BigQuery
CREATE DATABASE <name> CLONE <source_db> [ { AT | BEFORE } ( { TIMESTAMP => <timestamp> | OFFSET => <time_difference> | STATEMENT => <id> } ) ]	A clonagem de conjuntos de dados ainda não é suportada no BigQuery.
CREATE DATABASE <name> DATA_RETENTION_TIME_IN_DAYS = <num>	A viagem no tempo ao nível do conjunto de dados não é suportada no BigQuery. No entanto, a viagem no tempo para resultados de tabelas e consultas é suportada.
CREATE DATABASE <name> DEFAULT_DDL_COLLATION = '<collation_specification>'	A ordenação na DDL não é suportada no BigQuery.
CREATE DATABASE <name> COMMENT = '<string_literal>'	bq mk \ --description "<string_literal>" \ <name>
CREATE DATABASE <name> FROM SHARE <provider_account>.<share_name>	A criação de conjuntos de dados partilhados não é suportada no BigQuery. No entanto, os utilizadores podem partilhar o conjunto de dados através da consola/IU assim que o conjunto de dados for criado.
CREATE DATABASE <name> AS REPLICA OF <region>.<account>.<primary_db_name> AUTO_REFRESH_MATERIALIZED_VIEWS_ON_SECONDARY = { TRUE | FALSE } Nota: o Snowflake oferece a opção de manutenção automática em segundo plano das vistas materializadas na base de dados secundária, que não é suportada no 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: o BigQuery suporta a cópia de conjuntos de dados através do Serviço de transferência de dados do BigQuery. Consulte aqui os pré-requisitos para copiar um conjunto de dados.

O BigQuery também oferece as seguintes opções de comando bq mk, que não têm um análogo direto no Snowflake:

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

ALTER DATABASE declaração

Esta secção vai usar comandos da CLI do BigQuery correspondentes aos comandos do Snowflake para abordar as diferenças nas declarações ALTER.

Snowflake	BigQuery
ALTER DATABASE [ IF EXISTS ] <name> RENAME TO <new_db_name>	A mudança do nome de conjuntos de dados não é suportada no BigQuery, mas a cópia de conjuntos de dados é suportada.
ALTER DATABASE <name> SWAP WITH <target_db_name>	A troca de conjuntos de dados não é suportada no BigQuery.
ALTER DATABASE <name> SET [DATA_RETENTION_TIME_IN_DAYS = <num>] [ DEFAULT_DDL_COLLATION = '<value>']	A gestão da retenção e da organização de dados ao nível do conjunto de dados não é suportada no 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> ... ]	Conceito não suportado no BigQuery.
ALTER DATABASE <name> DISABLE REPLICATION [ TO ACCOUNTS <snowflake_region>.<account_name> [ , <snowflake_region>.<account_name> ... ]]	Conceito não suportado no BigQuery.
ALTER DATABASE <name> SET AUTO_REFRESH_MATERIALIZED_VIEWS_ON_SECONDARY = { TRUE | FALSE }	Conceito não suportado no BigQuery.
ALTER DATABASE <name> REFRESH	Conceito não suportado no BigQuery.
ALTER DATABASE <name> ENABLE FAILOVER TO ACCOUNTS <snowflake_region>.<account_name> [ , <snowflake_region>.<account_name> ... ]	Conceito não suportado no BigQuery.
ALTER DATABASE <name> DISABLE FAILOVER [ TO ACCOUNTS <snowflake_region>.<account_name> [ , <snowflake_region>.<account_name> ... ]]	Conceito não suportado no BigQuery.
ALTER DATABASE <name> PRIMARY	Conceito não suportado no BigQuery.

DROP DATABASE declaração

Esta secção vai usar o comando da CLI do BigQuery correspondente ao comando do Snowflake para abordar a diferença na declaração DROP.

Snowflake	BigQuery
DROP DATABASE [ IF EXISTS ] <name> [ CASCADE | RESTRICT ] Nota: no Snowflake, a eliminação de uma base de dados não a remove permanentemente do sistema. É retida uma versão da base de dados eliminada durante o número de dias especificado pelo parâmetro DATA_RETENTION_TIME_IN_DAYS para a base de dados.	bq rm -r -f -d <name> Where -r consiste em remover todos os objetos no conjunto de dados -f is to skip confirmation for execution -d indica o conjunto de dados Nota: no BigQuery, a eliminação de um conjunto de dados é permanente. Além disso, a eliminação em cascata não é suportada ao nível do conjunto de dados, uma vez que todos os dados e objetos no conjunto de dados são eliminados.

O Snowflake também suporta o comando UNDROP DATASET que restaura a versão mais recente de conjuntos de dados eliminados. Atualmente, esta opção não é suportada no BigQuery ao nível do conjunto de dados.

USE DATABASE declaração

O Snowflake oferece a opção de definir a base de dados para uma sessão de utilizador através do comando USE DATABASE. Isto elimina a necessidade de especificar nomes de objetos totalmente qualificados em comandos SQL. O BigQuery não oferece nenhuma alternativa ao comando USE DATABASE do Snowflake.

SHOW DATABASE declaração

Esta secção vai usar o comando da CLI do BigQuery correspondente ao comando do Snowflake para abordar a diferença na declaração SHOW.

Snowflake	BigQuery
SHOW DATABASES Nota: o Snowflake oferece uma única opção para listar e mostrar detalhes sobre todas as bases de dados, incluindo as bases de dados eliminadas que estão dentro do período de retenção.	bq ls --format=prettyjson e / ou bq show <dataset_name> Nota: no BigQuery, o comando ls fornece apenas nomes de conjuntos de dados e informações básicas, e o comando show fornece detalhes como a data/hora da última modificação, as LCAs e as etiquetas de um conjunto de dados. O BigQuery também fornece mais detalhes sobre os conjuntos de dados através do Information Schema.
SHOW TERSE DATABASES Nota: com a opção TERSE, o Snowflake permite apresentar apenas informações/campos específicos sobre conjuntos de dados.	Conceito não suportado no BigQuery.
SHOW DATABASES HISTORY	O conceito de viagem no tempo não é suportado no BigQuery ao nível do conjunto de dados.
SHOW DATABASES [LIKE '<pattern>'] [STARTS WITH '<name_string>']	A filtragem de resultados por nomes de conjuntos de dados não é suportada no BigQuery. No entanto, a filtragem por etiquetas é suportada.
SHOW DATABASES LIMIT <rows> [FROM '<name_string>'] Nota: por predefinição, o Snowflake não limita o número de resultados. No entanto, o valor de LIMIT não pode exceder 10 000.	bq ls \ --max_results <rows> Nota: por predefinição, o BigQuery só apresenta 50 resultados.

O BigQuery também oferece as seguintes opções de comando bq, que não têm um análogo direto no Snowflake:

• bq ls --format=pretty: devolve resultados formatados básicos
• *bq ls -a: *Returns only anonymous datasets (the ones starting with an underscore)
• bq ls --all: devolve todos os conjuntos de dados, incluindo os anónimos
• bq ls --filter labels.key:value: devolve resultados filtrados pela etiqueta do conjunto de dados
• bq ls --d: exclui conjuntos de dados anónimos dos resultados
• bq show --format=pretty: devolve resultados formatados básicos detalhados para todos os conjuntos de dados

Gestão do SCHEMA

O Snowflake oferece vários comandos de gestão de esquemas semelhantes aos comandos de gestão de bases de dados. Este conceito de criação e gestão de esquemas não é suportado no BigQuery.

No entanto, o BigQuery permite-lhe especificar o esquema de uma tabela quando carrega dados para uma tabela e quando cria uma tabela vazia. Em alternativa, pode usar a deteção automática de esquemas para formatos de dados suportados.

Gestão do SHARE

O Snowflake oferece vários comandos de gestão de partilha semelhantes aos comandos de gestão de bases de dados e esquemas. Este conceito de criar e gerir a partilha não é suportado no BigQuery.

DDL de tabelas, vistas e sequências

CREATE TABLE declaração

A maioria das declarações CREATE TABLE do Snowflake é compatível com o BigQuery, exceto os seguintes elementos de sintaxe, que não são usados no 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: as restrições UNIQUE e PRIMARY KEY são informativas e não são aplicadas pelo 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 ) onde table_constraints estão: [UNIQUE(column_name [, ... ])] [PRIMARY KEY(column_name [, ...])] [FOREIGN KEY(column_name [, ...]) REFERENCES reftable [(refcolumn)] Nota: UNIQUE e as restrições PRIMARY KEY são informativas e não são aplicadas pelo sistema Snowflake.	CREATE TABLE table_name ( col1 data_type1[,...] ) PARTITION BY column_name CLUSTER BY column_name [, ...] Nota: o BigQuery não usa restrições de tabelas UNIQUE, PRIMARY KEY nem FOREIGN KEY. Para alcançar uma otimização semelhante à que estas restrições oferecem durante a execução de consultas, crie partições e clusters nas suas tabelas do BigQuery. CLUSTER BY suporta até quatro colunas.
CREATE TABLE table_name LIKE original_table_name	Consulte este exemplo para saber como usar as tabelas INFORMATION_SCHEMA para copiar nomes de colunas, tipos de dados e restrições NOT NULL para uma nova tabela.
CREATE TABLE table_name ( col1 data_type1 ) BACKUP NO Nota:no Snowflake, a definição BACKUP NO é especificada para "poupar tempo de processamento ao criar imagens instantâneas e restaurar a partir de imagens instantâneas, e para reduzir o espaço de armazenamento".	A opção de tabela BACKUP NO não é usada nem necessária porque o BigQuery mantém automaticamente até 7 dias de versões do histórico de todas as suas tabelas, sem qualquer efeito no tempo de processamento nem no armazenamento faturado.
CREATE TABLE table_name ( col1 data_type1 ) table_attributes onde table_attributes estão: [DISTSTYLE {AUTO|EVEN|KEY|ALL}] [DISTKEY (column_name)] [[COMPOUND|INTERLEAVED] SORTKEY (column_name [, ...])]	O BigQuery suporta o clustering, o que permite armazenar chaves por ordem alfabética.
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 ...

O BigQuery também suporta a declaração DDL CREATE OR REPLACE TABLE, que substitui uma tabela se já existir.

A declaração CREATE TABLEdo BigQuery também suporta as seguintes cláusulas, que não têm um equivalente no Snowflake:

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

Para mais informações sobre o CREATE TABLE no BigQuery, consulte os exemplos de declarações CREATE TABLE na documentação de DDL.

ALTER TABLE declaração

Esta secção vai usar comandos da CLI do BigQuery correspondentes aos comandos do Snowflake para abordar as diferenças nas declarações ALTER para tabelas.

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>	A troca de tabelas não é suportada no BigQuery.
ALTER TABLE <name> SET [DEFAULT_DDL_COLLATION = '<value>']	A gestão da ordenação de dados para tabelas não é suportada no 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>')

Além disso, o Snowflake oferece opções de clustering, colunas e restrições para alterar tabelas que não são suportadas pelo BigQuery.

DROP TABLE e UNDROP TABLE extratos

Esta secção vai usar o comando da CLI do BigQuery correspondente ao comando do Snowflake para abordar a diferença nas declarações DROP e UNDROP.

Snowflake	BigQuery
DROP TABLE [IF EXISTS] <table_name> [CASCADE | RESTRICT] Nota: no Snowflake, a eliminação de uma tabela não a remove permanentemente do sistema. É retida uma versão da tabela eliminada durante o número de dias especificado pelo DATA_RETENTION_TIME_IN_DAYS parâmetro para a base de dados.	bq rm -r -f -d <dataset_name>.<table_name> Where -r serve para remover todos os objetos no conjunto de dados -f serve para ignorar a confirmação para execução -d indica o conjunto de dados Nota: no BigQuery, a eliminação de uma tabela também não é permanente, mas é mantida uma captura de ecrã apenas durante 7 dias.
UNDROP TABLE <table_name>	bq cp \ <dataset_name>.<table_name>@<unix_timestamp> <dataset_name>.<new_table_name> Nota: no BigQuery, tem de determinar primeiro uma indicação de tempo UNIX de quando a tabela existia (em milissegundos). Em seguida, copie a tabela nessa data/hora para uma nova tabela. A nova tabela tem de ter um nome diferente do da tabela eliminada.

CREATE EXTERNAL TABLE declaração

O BigQuery permite criar tabelas externas permanentes e temporárias e consultar dados diretamente a partir de:

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

O Snowflake permite criar uma tabela externa permanente que, quando consultada, lê dados de um conjunto de um ou mais ficheiros num estágio externo especificado.

Esta secção vai usar o comando da CLI do BigQuery correspondente ao comando do Snowflake para abordar as diferenças na declaração 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: o Snowflake permite preparar os ficheiros que contêm dados a serem lidos e especificar opções de tipo de formato para tabelas externas. O BigQuery suporta todos os tipos de formatos do Snowflake, exceto o tipo XML: CSV, JSON, AVRO, PARQUET e ORC.	[1] bq mk \ --external_table_definition=definition_file \ dataset.table OR [2] bq mk \ --external_table_definition=schema_file@source_format={Cloud Storage URI | drive_URI} \ dataset.table OR [3] bq mk \ --external_table_definition=schema@source_format = {Cloud Storage URI | drive_URI} \ dataset.table Nota: o BigQuery permite criar uma tabela permanente associada à sua origem de dados através de um ficheiro de definição de tabela [1], um ficheiro de esquema JSON [2] ou uma definição de esquema inline [3]. A preparação de ficheiros para leitura e a especificação de opções de tipo de formato não são suportadas no 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: atualmente, o BigQuery não suporta nenhuma das opções de parâmetros opcionais fornecidas pelo Snowflake para criar tabelas externas. Para a partição, o BigQuery suporta a utilização da pseudocoluna _FILE_NAME para criar tabelas/vistas particionadas com base nas tabelas externas. Para mais informações, consulte o artigo Consulte a pseudocoluna _FILE_NAME.

Além disso, o BigQuery também suporta consultar dados particionados externamente nos formatos AVRO, PARQUET, ORC, JSON e CSV armazenados no Google Cloud Storage através de um esquema de partição de colmeias predefinido.

CREATE VIEW declaração

A tabela seguinte mostra os equivalentes entre o Snowflake e o BigQuery para a declaração 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 ...
Não suportado	CREATE VIEW IF NOT EXISTS view_name OPTIONS(view_option_list) AS SELECT ...
CREATE VIEW view_name AS SELECT ... WITH NO SCHEMA BINDING	No BigQuery, para criar uma vista, todos os objetos referenciados têm de existir. O BigQuery permite consultar origens de dados externas.

CREATE SEQUENCE declaração

As sequências não são usadas no BigQuery. Isto pode ser conseguido da seguinte forma em lote. Para mais informações sobre chaves substitutas e dimensões que mudam lentamente (SCD), consulte os seguintes guias:

• Chaves substitutas do BigQuery
• BigQuery e chaves substitutas: uma abordagem prática

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

LDD de carregamento e descarga de dados

O Snowflake suporta o carregamento e o descarregamento de dados através de comandos de gestão de fases, formatos de ficheiros e pipelines. O BigQuery também oferece várias opções, como bq load, Serviço de transferência de dados do BigQuery, bq extract, etc. Esta secção realça as diferenças na utilização destas metodologias para carregar e descarregar dados.

LDD da conta e da sessão

Os conceitos de conta e sessão do Snowflake não são suportados no BigQuery. O BigQuery permite a gestão de contas através do Cloud IAM a todos os níveis. Além disso, as transações com várias declarações ainda não são suportadas no BigQuery.

Funções definidas pelo utilizador (UDF)

Uma FDU permite-lhe criar funções para operações personalizadas. Estas funções aceitam colunas de entrada, realizam ações e devolvem o resultado dessas ações como valor

O Snowflake e o BigQuery suportam FDUs através de expressões SQL e código JavaScript.

Consulte o repositório do GitHub GoogleCloudPlatform/bigquery-utils/ para aceder a uma biblioteca de UDFs comuns do BigQuery.

Sintaxe CREATE FUNCTION

A tabela seguinte aborda as diferenças na sintaxe de criação de FDU de SQL entre o Snowflake e o 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: no SQL UDF do BigQuery, o tipo de dados de retorno é opcional. O BigQuery infere o tipo de resultado da função a partir do corpo da função SQL quando uma consulta chama a função.
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:no SQL UDF do BigQuery, a devolução do tipo de tabela não é suportada atualmente, mas está nos planos do produto e vai estar disponível em breve. No entanto, o BigQuery suporta a devolução de ARRAY do tipo STRUCT.
CREATE [SECURE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Nota: o Snowflake oferece uma opção segura para restringir a definição e os detalhes das UDF apenas a utilizadores autorizados (ou seja, utilizadores aos quais é concedida a função proprietária da vista).	CREATE FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Nota: a segurança das funções não é um parâmetro configurável no BigQuery. O BigQuery suporta a criação de funções e autorizações de IAM para restringir o acesso aos dados subjacentes e à definição de funções.
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: o comportamento das funções para entradas nulas é processado implicitamente no BigQuery e não tem de ser especificado como uma opção separada.
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:a volatilidade da função não é um parâmetro configurável no BigQuery. Toda a volatilidade das UDFs do BigQuery é equivalente à volatilidade do Snowflake (ou seja, não faz pesquisas na base de dados nem usa informações que não estejam diretamente presentes na respetiva lista de argumentos).IMMUTABLE
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: a utilização de aspas simples ou de uma sequência de carateres, como as aspas de dólar ($$) 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: o comportamento do procedimento para entradas nulas é processado implicitamente no BigQuery e não precisa de ser especificado como uma opção separada.
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:a volatilidade do procedimento não é um parâmetro configurável no BigQuery. É equivalente à volatilidade de IMMUTABLE da 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:atualmente, a adição de comentários ou descrições nas definições de procedimentos não é suportada no BigQuery.
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type [EXECUTE AS { CALLER | OWNER }] AS procedure_definition; Nota: o Snowflake suporta a especificação do autor da chamada ou do proprietário do procedimento para execução	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN procedure_definition END; Nota: os procedimentos armazenados do BigQuery são sempre executados como o autor da chamada

O BigQuery também suporta a declaração CREATE PROCEDURE IF NOT EXISTS, que trata a consulta como bem-sucedida e não toma nenhuma medida se já existir uma função com o mesmo nome.

Sintaxe DROP PROCEDURE

A tabela seguinte aborda as diferenças na sintaxe DROP FUNCTION entre o Snowflake e o BigQuery.

Snowflake	BigQuery
DROP PROCEDURE [IF EXISTS] procedure_name ([arg_data_type, ... ])	DROP PROCEDURE [IF EXISTS] dataset_name.procedure_name Nota: o BigQuery não requer a utilização da assinatura do procedimento (tipo de dados do argumento) para eliminar o procedimento.

O BigQuery requer que especifique o project_name se o procedimento não estiver localizado no projeto atual.

Comandos de procedimentos adicionais

O Snowflake fornece comandos adicionais, como ALTER PROCEDURE, DESC[RIBE] PROCEDURE, e SHOW PROCEDURES para gerir os procedimentos armazenados. Atualmente, não são suportados no BigQuery.

Metadados e declarações SQL de transações

Snowflake	BigQuery
BEGIN [ { WORK | TRANSACTION } ] [ NAME <name> ]; START_TRANSACTION [ name <name> ];	O BigQuery usa sempre o isolamento de instantâneos. Para ver detalhes, consulte Garantias de consistência noutro local deste documento.
COMMIT;	Não usado no BigQuery.
ROLLBACK;	Não usado no 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.	Não usado no BigQuery.

Declarações SQL multilinhas e com várias declarações

O Snowflake e o BigQuery suportam transações (sessões) e, por isso, suportam declarações separadas por pontos e vírgulas que são executadas em conjunto de forma consistente. Para mais informações, consulte o artigo Transações com vários extratos.

Colunas de metadados para ficheiros preparados

O Snowflake gera automaticamente metadados para ficheiros em preparações internas e externas. Estes metadados podem ser consultados e carregados numa tabela juntamente com as colunas de dados normais. Podem ser usadas as seguintes colunas de metadados:

• METADATA$FILENAME
• METADATA$FILE_ROW_NUMBER

Garantias de consistência e isolamento de transações

O Snowflake e o BigQuery são atómicos, ou seja, estão em conformidade com ACID ao nível de cada mutação em várias linhas.

Transações

A cada transação do Snowflake é atribuída uma hora de início exclusiva (inclui milissegundos) que é definida como o ID da transação. O Snowflake só suporta o nível de isolamento READ COMMITTED. No entanto, uma declaração pode ver as alterações feitas por outra declaração se ambas estiverem na mesma transação, mesmo que essas alterações ainda não tenham sido confirmadas. As transações do Snowflake adquirem bloqueios em recursos (tabelas) quando esse recurso está a ser modificado. Os utilizadores podem ajustar o tempo máximo que uma declaração bloqueada aguarda até atingir o limite de tempo. As instruções DML são confirmadas automaticamente se o parâmetro AUTOCOMMIT estiver ativado.

O BigQuery também suporta transações. O BigQuery ajuda a garantir o controlo de concorrência otimista (o primeiro a confirmar ganha) com o isolamento de instantâneos, em que uma consulta lê os últimos dados confirmados antes de começar. Esta abordagem garante o mesmo nível de consistência por linha, por mutação e entre linhas na mesma declaração DML, mas evita bloqueios. No caso de várias atualizações de DML na mesma tabela, o BigQuery muda para o controlo de concorrência pessimista. Os trabalhos de carregamento podem ser executados de forma totalmente independente e anexados a tabelas. No entanto, o BigQuery ainda não fornece um limite de transação explícito nem uma sessão.

Reversão

Se a sessão de uma transação do Snowflake for terminada inesperadamente antes de a transação ser confirmada ou revertida, a transação fica num estado desanexado. O utilizador deve executar SYSTEM$ABORT_TRANSACTION para anular a transação separada ou o Snowflake vai reverter a transação separada após quatro horas de inatividade. Se ocorrer um impasse, o Snowflake deteta o impasse e seleciona a declaração mais recente para reverter. Se a declaração DML numa transação aberta explicitamente falhar, as alterações são revertidas, mas a transação permanece aberta até ser confirmada ou revertida. Não é possível reverter as declarações DDL no Snowflake, uma vez que são confirmadas automaticamente.

O BigQuery suporta a declaração ROLLBACK TRANSACTION. Não existe nenhuma declaração ABORT no BigQuery.

Limites da base de dados

Verifique sempre a documentação pública do BigQuery para conhecer as quotas e os limites mais recentes. Muitas quotas para utilizadores de grande volume podem ser aumentadas contactando a equipa de apoio técnico do Google Cloud.

Por predefinição, todas as contas do Snowflake têm limites flexíveis definidos. Os limites flexíveis são definidos durante a criação da conta e podem variar. Muitos limites flexíveis do Snowflake podem ser aumentados através da equipa da conta do Snowflake ou de um pedido de apoio técnico.

A tabela seguinte mostra uma comparação dos limites da base de dados do Snowflake e do BigQuery.

Limite	Snowflake	BigQuery
Tamanho do texto da consulta	1 MB	1 MB
Número máximo de consultas simultâneas	XS Warehouse - 8 S Warehouse - 16 M Warehouse - 32 L Warehouse - 64 XL Warehouse - 128	100