SnowConvert AI - BigQuery - Tipos de dados¶

O Snowflake oferece suporte para a maioria dos tipos de dados SQL, com restrições específicas, em várias construções SQL, incluindo colunas, variáveis locais, expressões e parâmetros.

Tipo de dado booleano¶

BigQuery	Snowflake	Notas
BOOL/BOOLEAN	BOOLEAN

Tipo de dados Bytes¶

BigQuery	Snowflake	Notas
BYTES	BINARY	O tipo de dados BYTES não é compatível como Snowflake. BINARY é usado no lugar dele. Para obter mais informações, consulte adocumentação do tipo de dados BYTES.

Tipos de dados de data e hora¶

BigQuery	Snowflake	Notas
DATE	DATE
DATETIME	DATETIME	DATETIME é um alias para TIMESTAMP_NTZ no Snowflake.
TIMESTAMP	TIMESTAMP_TZ	O tipo de dados TIMESTAMP é convertido em TIMESTAMP_TZ. Para obter mais informações, consulte a documentação do tipo de dados TIMESTAMP.
TIME	TIME

Tipo de dados de geografia¶

BigQuery	Snowflake	Notas
GEOGRAPHY	GEOGRAPHY

Tipo de dados de intervalo¶

BigQuery	Snowflake	Notas
INTERVAL	VARCHAR(30)	O tipo de dados INTERVAL não é compatível como Snowflake. VARCHAR é usado no lugar dele. Para obter mais informações, consulte a documentação do tipo de dados INTERVAL.

Tipo de dados Json¶

BigQuery	Snowflake	Notas
JSON	VARIANT	O tipo de dados JSON não é compatível como Snowflake. VARIANT é usado no lugar dele. Para obter mais informações, consulte a Documentação do tipo de dados JSON.

Tipos de dados numéricos¶

BigQuery	Snowflake	Notas
INT64	INT	INT é um alias para o tipo de dados NUMBER no Snowflake. A precisão e a escala máximas são NUMBER(38,37).
INT	INT	INT é um alias para o tipo de dados NUMBER no Snowflake. A precisão e a escala máximas são NUMBER(38,37).
SMALLINT	SMALLINT	SMALLINT é um alias para o tipo de dados NUMBER no Snowflake. A precisão e a escala máximas são NUMBER(38,37).
INTEGER	INTEGER	INTEGER é um alias para o Tipo de dados NUMBER no Snowflake. A precisão e a escala máximas são NUMBER(38,37).
BIGINT	BIGINT	BIGINT é um alias para o tipo de dados NUMBER no Snowflake. A precisão e a escala máximas são NUMBER(38,37).
TINYINT	TINYINT	TINYINT é um alias para o tipo de dados NUMBER no Snowflake. A precisão e a escala máximas são NUMBER(38,37).
BYTEINT	BYTEINT	BYTEINT é um alias para o tipo de dados NUMBER no Snowflake. A precisão e a escala máximas são NUMBER(38,37).
NUMERIC	NUMERIC	NUMERIC é um alias para o tipo de dados NUMBER no Snowflake. A precisão e a escala máximas são NUMBER(38,37).
DECIMAL	DECIMAL	DECIMAL é um alias para o tipo de dados NUMBER no Snowflake. A precisão e a escala máximas são NUMBER(38,37).
BIGNUMERIC	NUMERIC	O Snowflake não tem suporte para o tipo de dados BIGNUMERIC. Use NUMERIC em vez disso. A precisão do BIGNUMERIC, 76,76, excede o limite do Snowflake (38), resultando em truncamento ou arredondamento, o que pode introduzir imprecisões significativas.
BIGDECIMAL	DECIMAL	O Snowflake não tem suporte para o tipo de dados BIGDECIMAL. Use NUMERIC em vez disso. A precisão do BIGDECIMAL, 76,76, excede o limite do Snowflake (38), resultando em truncamento ou arredondamento, o que pode introduzir imprecisões significativas.
FLOAT64	FLOAT

Tipos de dados de cadeia de caracteres¶

BigQuery	Snowflake	Notas
STRING	STRING	STRING é um alias para o tipo de dados VARCHAR no Snowflake. VARCHAR contém caracteres Unicode UTF-8.

ANY TYPE¶

Especificação de tradução para BigQueryde tipo de dados ANY TYPE

Descrição¶

A seguir, um trecho de informações sobre o uso de ANY TYPE dentro de instruções CREATE FUNCTION.

Um parâmetro com um tipo igual a ANY TYPE pode corresponder a mais de um tipo de argumento quando a função é chamada.

Se mais de um parâmetro tiver o tipo ANY TYPE, então BigQuery não impõe nenhum tipo de relação entre esses argumentos.

O tipo de retorno da função não pode ser ANY TYPE. Deve ser omitido, o que significa que deve ser determinado automaticamente com base em sql_expression, ou um tipo explícito.

Passar os argumentos da função de tipos incompatíveis com a definição da função resulta em um erro no momento da chamada.

Amostra de padrões da origem¶

Definição de tipo para UDFs¶

ANY TYPE só pode ser encontrado como o tipo para o parâmetro de uma função. O SnowConvert AI traduz automaticamente ANY TYPE para VARIANT.

BigQuery¶

CREATE FUNCTION addFourAndDivideAny(x ANY TYPE, y ANY TYPE)
AS (
  (x + 4) / y
);

Copy

Snowflake¶

CREATE FUNCTION addFourAndDivideAny (x VARIANT, y VARIANT)
RETURNS VARIANT
AS
$$
  ((x + 4) / y) :: VARIANT
$$;

Copy

ARRAY<T>¶

Especificação de tradução para o tipo de dados ARRAY de BigQuery para Snowflake

Descrição¶

Em BigQuery, uma matriz é uma lista ordenada de zero ou mais elementos de valores não matriz. Os elementos em uma matriz devem compartilhar o mesmo tipo. (Tipo de matriz. BigQuery)

Amostra de padrões da origem¶

BigQuery¶

CREATE TABLE test.arrayTable
(
  col1 ARRAY<INT64>
);

CREATE TABLE test.anotherArrayTable
(
  col2 ARRAY<INT64>
);

INSERT INTO test.arrayTable VALUES ([4, 10, 55]);
INSERT INTO test.arrayTable VALUES ([6, 7, 33]);
INSERT INTO test.arrayTable VALUES ([50, 12, 22]);

INSERT INTO test.anotherArrayTable VALUES ([9, 11, 52]);
INSERT INTO test.anotherArrayTable VALUES ([3, 18, 11]);
INSERT INTO test.anotherArrayTable VALUES ([33, 27, 43]);

Copy

Snowflake¶

CREATE TABLE test.arrayTable
(
  col1 ARRAY DEFAULT []
);

CREATE TABLE test.anotherArrayTable
(
  col2 ARRAY DEFAULT []
);

INSERT INTO test.arrayTable SELECT [4, 10, 55];
INSERT INTO test.arrayTable SELECT [6, 7, 33];
INSERT INTO test.arrayTable SELECT [50, 12, 22];

INSERT INTO test.anotherArrayTable SELECT [9, 11, 52];
INSERT INTO test.anotherArrayTable SELECT [3, 18, 11];
INSERT INTO test.anotherArrayTable SELECT [33, 27, 43];

Copy

Acesso de ARRAY por índice¶

BigQuery¶

SELECT
col1[0] + 4 AS byIndex,
col1[OFFSET(0)] + 4 AS byOffset,
col1[ORDINAL(1)] + 4 AS byOrdinal
FROM test.arrayTable ORDER BY col1[0];

Copy

Snowflake¶

SELECT
--** SSC-FDM-BQ0001 - ACCESSING ARRAYS PRODUCES NULL INSTEAD OF AN ERROR FOR POSITIVE OUT OF BOUNDS INDEXES IN SNOWFLAKE **
col1[0] + 4 AS byIndex,
--** SSC-FDM-BQ0001 - ACCESSING ARRAYS PRODUCES NULL INSTEAD OF AN ERROR FOR POSITIVE OUT OF BOUNDS INDEXES IN SNOWFLAKE **
col1[0] + 4 AS byOffset,
--** SSC-FDM-BQ0001 - ACCESSING ARRAYS PRODUCES NULL INSTEAD OF AN ERROR FOR POSITIVE OUT OF BOUNDS INDEXES IN SNOWFLAKE **
col1[1 - 1] + 4 AS byOrdinal
FROM
test.arrayTable
ORDER BY
--** SSC-FDM-BQ0001 - ACCESSING ARRAYS PRODUCES NULL INSTEAD OF AN ERROR FOR POSITIVE OUT OF BOUNDS INDEXES IN SNOWFLAKE **
col1[0];

Copy

Acesso seguro de ARRAY por índice¶

BigQuery¶

SELECT
col1[SAFE_OFFSET(0)] AS byOffsset,
col1[SAFE_OFFSET(-4)] AS byOffsetUnderflow,
col1[SAFE_OFFSET(500)] AS byOffsetOverflow,
col1[SAFE_ORDINAL(1)] AS byOrdinal,
col1[SAFE_ORDINAL(-4)] AS byOrdinalUnderflow,
col1[SAFE_ORDINAL(500)] AS byOrdinalOverflow
FROM test.arrayTable ORDER BY col1[0];

Copy

Snowflake¶

SELECT
PUBLIC.SAFE_OFFSET_UDF(col1, 0) AS byOffsset,
PUBLIC.SAFE_OFFSET_UDF(col1, -4) AS byOffsetUnderflow,
PUBLIC.SAFE_OFFSET_UDF(col1, 500) AS byOffsetOverflow,
PUBLIC.SAFE_OFFSET_UDF(col1, 1 - 1) AS byOrdinal,
PUBLIC.SAFE_OFFSET_UDF(col1, -4 - 1) AS byOrdinalUnderflow,
PUBLIC.SAFE_OFFSET_UDF(col1, 500 - 1) AS byOrdinalOverflow
FROM test.arrayTable ORDER BY 
--** SSC-FDM-BQ0001 - ACCESSING ARRAYS PRODUCES NULL INSTEAD OF AN ERROR FOR POSITIVE OUT OF BOUNDS INDEXES IN SNOWFLAKE **
col1[0];

Copy

INSERT com ARRAY na cláusula VALUES¶

BigQuery¶

INSERT INTO test.arrayTable VALUES ([4, 10]);

INSERT INTO test.arrayTable (COL1)
VALUES ([1, 2, 3]), ([4, 5, 6]);

SELECT col1 FROM test.arrayTable ORDER BY col1[0], col1[1];

Copy

Snowflake¶

INSERT INTO test.arrayTable SELECT [4, 10];

INSERT INTO test.arrayTable (COL1)
SELECT [1, 2, 3] 
UNION ALL
SELECT [4, 5, 6];

SELECT col1 FROM
  test.arrayTable
ORDER BY
  --** SSC-FDM-BQ0001 - ACCESSING ARRAYS PRODUCES NULL INSTEAD OF AN ERROR FOR POSITIVE OUT OF BOUNDS INDEXES IN SNOWFLAKE **
  col1[0],
  --** SSC-FDM-BQ0001 - ACCESSING ARRAYS PRODUCES NULL INSTEAD OF AN ERROR FOR POSITIVE OUT OF BOUNDS INDEXES IN SNOWFLAKE **
  col1[1];

Copy

Instrução MERGE¶

BigQuery¶

MERGE INTO test.anotherArrayTable
USING test.arrayTable
ON col1[0] = col2[0]
WHEN MATCHED THEN UPDATE SET col2 = col1
WHEN NOT MATCHED THEN INSERT VALUES ([100, 100, 100]);

SELECT col2 FROM test.anotherArrayTable ORDER BY col2[0];

Copy

Snowflake¶

MERGE INTO test.anotherArrayTable
USING test.arrayTable
ON col1[0] = col2[0]
WHEN MATCHED THEN UPDATE SET col2 = col1
WHEN NOT MATCHED THEN INSERT VALUES ([100, 100, 100]) !!!RESOLVE EWI!!! /*** SSC-EWI-0073 - PENDING FUNCTIONAL EQUIVALENCE REVIEW FOR 'MergeStatement' NODE ***/!!!;

SELECT col2 FROM
  test.anotherArrayTable
ORDER BY
  --** SSC-FDM-BQ0001 - ACCESSING ARRAYS PRODUCES NULL INSTEAD OF AN ERROR FOR POSITIVE OUT OF BOUNDS INDEXES IN SNOWFLAKE **
  col2[0];

Copy

Inserção/atualização de valor de coluna ARRAY DEFAULT¶

BigQuery¶

 INSERT INTO test.arrayTable VALUES (DEFAULT);

UPDATE test.arrayTable
SET col1 = DEFAULT
WHERE TRUE;

SELECT col1 FROM test.arrayTable;

Copy

Snowflake¶

 INSERT INTO test.arrayTable SELECT [];

UPDATE test.arrayTable
SET col1 = DEFAULT
WHERE TRUE;

SELECT col1 FROM test.arrayTable;

Copy

INSERT/UPDATE com valor NULL¶

BigQuery¶

 INSERT INTO test.arrayTable
  SELECT
    numbers
  FROM
    (SELECT [6] AS numbers
    UNION ALL
    SELECT CAST(NULL AS ARRAY<INT64>));

UPDATE test.arrayTable
SET col1 = NULL
WHERE ARRAY_LENGTH(col1) > 1;

SELECT col1 FROM test.arrayTable ORDER BY ARRAY_LENGTH(col1);

Copy

Snowflake¶

INSERT INTO test.arrayTable
SELECT
  numbers
FROM
  (SELECT [6] AS numbers
  UNION ALL
  SELECT IFNULL(CAST(NULL AS ARRAY), []));

UPDATE test.arrayTable
SET col1 = IFNULL(NULL, [])
WHERE ARRAY_SIZE(col1) > 1;

SELECT col1 FROM test.arrayTable ORDER BY ARRAY_SIZE(col1);

Copy

Concatenação de ARRAY¶

BigQuery¶

SELECT [50, 30, 12] || [22, 33, 44] AS result;

Copy

Snowflake¶

SELECT ARRAY_CAT([50, 30, 12], [22, 33, 44]) AS result;

Copy

ARRAY usado como parâmetro/tipo de retorno¶

BigQuery¶

CREATE FUNCTION test.myArrayFunction (valuesArray ARRAY<INT64>, otherValue INTEGER)
RETURNS ARRAY<INT64>
AS
(
  valuesArray || [otherValue]
);

SELECT test.myArrayFunction([5, 20, 10], 55) AS result;

Copy

Snowflake¶

CREATE FUNCTION test.myArrayFunction (valuesArray ARRAY, otherValue INTEGER)
RETURNS ARRAY
AS
$$
  ARRAY_CAT(valuesArray, [otherValue])
$$;

SELECT test.myArrayFunction([5, 20, 10], 55) AS result;

Copy

Problemas conhecidos¶

1. O acesso não seguro de ARRAY não falhará para índices positivos fora dos limites

Em BigQuery, o acesso a um elemento de matriz por índice falhará para qualquer valor de índice que seja muito baixo (underflow) ou muito alto (overflow) quando não estiver usando SAFE_OFFSET ou SAFE_ORDINAL. No entanto, no Snowflake, os erros são lançados apenas em casos de underflow ; qualquer índice que causaria um erro de overflow gerará um valor NULL em vez disso.

Quando acesso não seguro aos elementos de uma matriz é detectado, o SnowConvert AI geraSSC-FDM-BQ0001 para alertar o usuário sobre isso.

BYTES¶

Tipo de dados de bytes e usos

Descrição¶

Sequência de bytes com um máximo de L bytes permitidos na cadeia de caracteres binária. O comprimento máximo é de 8 MB (8.388.608 bytes). Para obter mais informações, consulte o tipo de dados BigQuery BYTES.

Nota

O tipo de dados BYTES não é compatível com o Snowflake, atualmente transformado para BINARY.#x20;

Amostra de padrões da origem¶

Formato de saída BYTES¶

O formato de saída padrão para tipos de dados binários em BigQuery é “BASE64” e no Snowflake é “HEX”. Por esse motivo, quando uma coluna binária é selecionada, a função BASE64_ENCODE é adicionada automaticamente. Para manter a formatação padrão de BigQuery.

BigQuery¶

 CREATE OR REPLACE TABLE bytesTable
(
  COL1 BYTES,
  COL2 BYTES(20)
);

INSERT INTO bytesTable VALUES (B"01020304", B"""AABBCCDD""");
INSERT INTO bytesTable VALUES (B'''\x01\x02\x03''', B"/+A=");

SELECT COL1 FROM bytesTable;

Copy

Snowflake:¶

CREATE OR REPLACE TABLE bytesTable
(
  COL1 BINARY,
  COL2 BINARY(20)
);

INSERT INTO bytesTable
SELECT
  TRY_TO_BINARY('01020304', 'utf-8'),
  TRY_TO_BINARY('AABBCCDD', 'utf-8');
  
INSERT INTO bytesTable
SELECT
  TRY_TO_BINARY('\x01\x02\x03', 'utf-8'),
  TRY_TO_BINARY('/+A=', 'utf-8');
  
SELECT BASE64_ENCODE( COL1) FROM bytesTable;

Copy

Caso ele não seja adicionado automaticamente e você queira ver os dados em formato BASE64, você pode usar a função BASE64_ENCODE ou definir o formato [BINARY_OUTPUT_FORMAT:(https://docs.snowflake.com/en/sql-reference/parameters#binary-output-format).

Literal BYTES¶

Os casos a seguir representam as formas que podem ser usadas para formatar literais de byte em BigQuery.

 B"abc"
B'''abc'''
b"""abc"""

Copy

Esses literais não são compatíveis com o Snowflake, mas em vez disso a função TRY_TO_BINARY pode ser usada para converter a expressão de entrada em um valor binário. Esta função é uma versão especial de TO_BINARY que realiza a mesma operação, mas com suporte para tratamento de erros.

É importante levar em consideração que o formato binário para a conversão pode ser: HEX, BASE64 ou UTF-8. O padrão é o valor do parâmetro de sessão BINARY_INPUT_FORMAT. Se este parâmetro não for definido, o padrão é .

Observações¶

Tenha em mente que o formato de saída padrão para tipos de dados binários em BigQuery é “BASE64” e no Snowflake é “HEX”. Você pode usar a função BASE64_ENCODE ou definir o formato BINARY_OUTPUT_FORMAT se quiser visualizar os dados em formato BASE64.
Os únicos formatos suportados pelo Snowflake são: HEX, BASE64ou UTF-8. Para obter mais informações, consulte Entrada e saída binária no Snowflake.
Funções binárias usadas para inserir dados em uma cláusula de valores não são aceitas no Snowflake.

GEOGRAPHY¶

Tipo de dados e usos GEOGRAPHY

Descrição¶

Uma coleção de pontos, linhas e polígonos, representada como um conjunto de pontos ou um subconjunto da superfície da Terra. Para obter mais informações, consulte o tipo de dadosBigQuery GEOGRAPHY.

Sucesso

Tipo de dados suportado no Snowflake.

Amostra de padrões da origem¶

Formato de saída GEOGRAPHY¶

O formato de saída padrão para tipos de dados de geografia em BigQuery é WKT (texto bem conhecido) e no SnowflakeWKB (binário bem conhecido). Por esse motivo, quando as colunas de geografia são selecionadas, a função ST_ASWKT é adicionada automaticamente. Além disso, quando todas as colunas de uma tabela são selecionadas e ela contém uma coluna de Geografia, GEOGRAPHY_OUTPUT_FORMAT é definido como WKT. Isso é feito para manter o formato padrão BigQuery.

BigQuery¶

CREATE OR REPLACE TABLE test.geographyType
(
  COL1 GEOGRAPHY
);

INSERT INTO test.geographyType VALUES
    (ST_GEOGFROMTEXT('POINT(-122.35 37.55)')), (ST_GEOGFROMTEXT('LINESTRING(-124.20 42.00, -120.01 41.99)'));

SELECT COL1 FROM test.geographyType;
SELECT * FROM test.geographyType;	

Copy

Snowflake¶

CREATE OR REPLACE TABLE test.geographyType
(
  COL1 GEOGRAPHY
);

INSERT INTO test.geographyType
VALUES
    (
     --** SSC-FDM-BQ0010 - THE FUNCTION 'ST_GEOGFROMTEXT' IS NOT REQUIRED IN SNOWFLAKE. **
     'POINT(-122.35 37.55)'), (
     --** SSC-FDM-BQ0010 - THE FUNCTION 'ST_GEOGFROMTEXT' IS NOT REQUIRED IN SNOWFLAKE. **
     'LINESTRING(-124.20 42.00, -120.01 41.99)');
     
SELECT ST_ASWKT( COL1) FROM test.geographyType;
            
ALTER SESSION SET GEOGRAPHY_OUTPUT_FORMAT = 'WKT';
SELECT * FROM test.geographyType;

Copy

Caso ele não seja adicionado automaticamente e você queira ver os dados em formato WKT, você pode usar a função ST_ASWKT ou definir o formato [GEOGRAPHY_OUTPUT_FORMAT:(https://docs.snowflake.com/en/sql-reference/parameters#geography-output-format).

Inserir dados de GEOGRAPHY¶

Para inserir dados em colunas do tipo geografia, nenhuma função é necessária, porque o Snowflake detecta automaticamente que os dados seguem o padrão WGS 84.

Observações¶

Tenha em mente que o formato de saída padrão para tipos de dados de geografia é WKT**(texto bem conhecido)** e, no Snowflake,WKB (binário bem conhecido). Você poderá usar o formato ST_ASWKT function or set the GEOGRAPHY_OUTPUT_FORMAT se quiser visualizar os dados em formato WKT.
As funções de geografia usadas para inserir dados em uma cláusula de valores não são necessárias no Snowflake.

INTERVAL¶

Tipo de dados de intervalo e usos

Descrição¶

Um objeto INTERVAL representa duração ou quantidade de tempo, sem se referir a qualquer ponto específico no tempo. Não há equivalente no Snowflake, então ele é transformado em Varchar (Referência de linguagem BigQuery, tipo de dados INTERVAL)

Sintaxe

INTERVAL int64_expression datetime_part

INTERVAL datetime_parts_string starting_datetime_part TO ending_datetime_part

Copy

Amostra de padrões da origem¶

Intervalo com uma única parte DateTime¶

BigQuery¶

SELECT INTERVAL 1 YEAR;

SELECT CURRENT_DATE + INTERVAL 1 YEAR, 
  CURRENT_DATE + INTERVAL 1 QUARTER,
  CURRENT_DATE + INTERVAL 1 MONTH,
  CURRENT_DATE + INTERVAL 1 WEEK,
  CURRENT_DATE + INTERVAL 1 DAY,
  CURRENT_DATE + INTERVAL 1 HOUR,
  CURRENT_DATE + INTERVAL 1 MINUTE,
  CURRENT_DATE + INTERVAL 1 SECOND;

Copy

Resultado¶

1-0 0 0:0:0

Copy

2024-10-13T00:00:00
2024-01-13T00:00:00
2023-11-13T00:00:00
2023-10-20T00:00:00
2023-10-14T00:00:00
2023-10-13T01:00:00
2023-10-13T00:01:00
2023-10-13T00:00:01

Copy

Snowflake¶

SELECT
!!!RESOLVE EWI!!! /*** SSC-EWI-0107 - INTERVAL LITERAL IS NOT SUPPORTED BY SNOWFLAKE IN THIS SCENARIO  ***/!!! INTERVAL 1 YEAR;

SELECT
CURRENT_DATE() + INTERVAL '1 year',
CURRENT_DATE() + INTERVAL '1 quarter',
CURRENT_DATE() + INTERVAL '1 month',
CURRENT_DATE() + INTERVAL '1 week',
CURRENT_DATE() + INTERVAL '1 day',
CURRENT_DATE() + INTERVAL '1 hour',
CURRENT_DATE() + INTERVAL '1 minute',
CURRENT_DATE() + INTERVAL '1 second';

Copy

Resultado¶

2024-10-13
2024-01-13
2023-11-13
2023-10-20
2023-10-14
2023-10-13 01:00:00.000
2023-10-13 00:01:00.000
2023-10-13 00:00:01.000

Copy

O Snowflake não suporta o cenário em que o tipo de dados Interval é consultado diretamente; pelo contrário, quando é usado como um operador para uma determinada data, sua tradução é feita usando uma [constante Interval].(https://docs. snowflake.com/en/sql-reference/data-types-datetime.html#interval-constants) (se possível).

Intervalo com um intervalo de partes DateTime¶

BigQuery¶

 SELECT INTERVAL '2-1 10' YEAR TO DAY;

SELECT CURRENT_DATE + INTERVAL '2-11' YEAR TO MONTH,
  CURRENT_DATE + INTERVAL '2-11 28' YEAR TO DAY,
  CURRENT_DATE + INTERVAL '2-11 28 16' YEAR TO HOUR,
  CURRENT_DATE + INTERVAL '2-11 28 16:15' YEAR TO MINUTE,
  CURRENT_DATE + INTERVAL '2-11 28 16:15:14' YEAR TO SECOND,
  CURRENT_DATE + INTERVAL '11 28' MONTH TO DAY,
  CURRENT_DATE + INTERVAL '11 28 16' MONTH TO HOUR,
  CURRENT_DATE + INTERVAL '11 28 16:15' MONTH TO MINUTE,
  CURRENT_DATE + INTERVAL '11 28 16:15:14' MONTH TO SECOND,
  CURRENT_DATE + INTERVAL '28 16' DAY TO HOUR,
  CURRENT_DATE + INTERVAL '28 16:15' DAY TO MINUTE,
  CURRENT_DATE + INTERVAL '28 16:15:14' DAY TO SECOND,
  CURRENT_DATE + INTERVAL '16:15' HOUR TO MINUTE,
  CURRENT_DATE + INTERVAL '16:15:14' HOUR TO SECOND,
  CURRENT_DATE + INTERVAL '15:14' MINUTE TO SECOND;

Copy

Resultado¶

2-1 10 0:0:0

Copy

2026-09-13T00:00:00
2026-10-11T00:00:00
2026-10-11T16:00:00
2026-10-11T16:15:00
2026-10-11T16:15:14
2024-10-11T00:00:00
2024-10-11T16:00:00
2024-10-11T16:15:00
2024-10-11T16:15:14
2023-11-10T16:00:00
2023-11-10T16:15:00
2023-11-10T16:15:14
2023-10-13T16:15:00
2023-10-13T16:15:14
2023-10-13T00:15:14

Copy

Snowflake¶

 SELECT
!!!RESOLVE EWI!!! /*** SSC-EWI-0107 - INTERVAL LITERAL IS NOT SUPPORTED BY SNOWFLAKE IN THIS SCENARIO  ***/!!! INTERVAL '2-1 10' YEAR TO DAY;

SELECT
CURRENT_DATE() + INTERVAL '2y, 11mm',
CURRENT_DATE() + INTERVAL '2y, 11mm, 28d',
CURRENT_DATE() + INTERVAL '2y, 11mm, 28d, 16h',
CURRENT_DATE() + INTERVAL '2y, 11mm, 28d, 16h, 15m',
CURRENT_DATE() + INTERVAL '2y, 11mm, 28d, 16h, 15m, 14s',
CURRENT_DATE() + INTERVAL '11mm, 28d',
CURRENT_DATE() + INTERVAL '11mm, 28d, 16h',
CURRENT_DATE() + INTERVAL '11mm, 28d, 16h, 15m',
CURRENT_DATE() + INTERVAL '11mm, 28d, 16h, 15m, 14s',
CURRENT_DATE() + INTERVAL '28d, 16h',
CURRENT_DATE() + INTERVAL '28d, 16h, 15m',
CURRENT_DATE() + INTERVAL '28d, 16h, 15m, 14s',
CURRENT_DATE() + INTERVAL '16h, 15m',
CURRENT_DATE() + INTERVAL '16h, 15m, 14s',
CURRENT_DATE() + INTERVAL '15m, 14s';

Copy

Resultado¶

2026-09-13
2026-10-11
2026-10-11 16:00:00.000
2026-10-11 16:15:00.000
2026-10-11 16:15:14.000
2024-10-11
2024-10-11 16:00:00.000
2024-10-11 16:15:00.000
2024-10-11 16:15:14.000
2023-11-10 16:00:00.000
2023-11-10 16:15:00.000
2023-11-10 16:15:14.000
2023-10-13 16:15:00.000
2023-10-13 16:15:14.000
2023-10-13 00:15:14.000

Copy

O valor do intervalo é transformado para um formato com suporte do Snowflake e depois inserido como texto dentro da coluna. Como o Snowflake não oferece suporte a intervalo como tipo de dados, ele só é compatível com operações aritméticas. Para usar o valor, ele precisa ser extraído e usado como uma constante de intervalo ( se possível).

Intervalo como um tipo de dados de Coluna¶

BigQuery¶

 CREATE OR REPLACE TABLE test.my_table (
  id INT NOT NULL,
  interval_column INTERVAL
);

INSERT INTO test.my_table
VALUES (1, INTERVAL '2-11 28' YEAR TO DAY);

INSERT INTO test.my_table
VALUES (2, INTERVAL '2-11 28 16:15:14' YEAR TO SECOND);

INSERT INTO test.my_table
VALUES (3, INTERVAL '11 28 16:15:14' MONTH TO SECOND);

INSERT INTO test.my_table
VALUES (4, INTERVAL '15:14' MINUTE TO SECOND);

SELECT * FROM test.my_table;

Copy

Resultado¶

ID	interval_column
1	2-11 28 0:0:0
2	2-11 28 16:15:14
3	0-11 28 16:15:14
4	0-0 0 0:15:14

Snowflake¶

 CREATE OR REPLACE TABLE test.my_table (
  id INT NOT NULL,
interval_column VARCHAR(30) !!!RESOLVE EWI!!! /*** SSC-EWI-0036 - INTERVAL DATA TYPE CONVERTED TO VARCHAR ***/!!!
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "bigquery",  "convertedOn": "04/01/2025",  "domain": "test" }}';

INSERT INTO test.my_table
VALUES (1, '2y, 11mm, 28d');

INSERT INTO test.my_table
VALUES (2, '2y, 11mm, 28d, 16h, 15m, 14s');

INSERT INTO test.my_table
VALUES (3, '11mm, 28d, 16h, 15m, 14s');

INSERT INTO test.my_table
VALUES (4, '15m, 14s');

SELECT * FROM
test.my_table;

Copy

Resultado¶

ID	interval_column
1	2y, 11mm, 28d
2	2y, 11mm, 28d, 16h, 15m, 14s
3	11mm, 28d, 16h, 15m, 14s
4	15m, 14s

Em BigQuery, a parte datetime_ segue o próximo formato canônico:

[sign]Y-M [sign]D [sign]H:M:S[.F]

Copy

Comparação de intervalos¶

BigQuery¶

SELECT INTERVAL 1 YEAR = INTERVAL 1 YEAR;

SELECT CURRENT_DATE + INTERVAL '-2 -16' DAY TO HOUR =  CURRENT_DATE + INTERVAL '-2 -16' DAY TO HOUR;

SELECT INTERVAL '-2 -16' DAY TO HOUR != INTERVAL '-2 16' DAY TO HOUR,
  INTERVAL '-2 -16' DAY TO HOUR <> INTERVAL '-2 16' DAY TO HOUR,
  INTERVAL '2 16:15' DAY TO MINUTE = INTERVAL '2 -16:15' DAY TO MINUTE,
  INTERVAL '2 16:15' DAY TO MINUTE > INTERVAL '2 -16:15' DAY TO MINUTE,
  INTERVAL '2 16:15' DAY TO MINUTE >= INTERVAL '2 -16:15' DAY TO MINUTE,
  INTERVAL '2 16:15' DAY TO MINUTE < INTERVAL '2 -16:15' DAY TO MINUTE,
  INTERVAL '2 16:15' DAY TO MINUTE <= INTERVAL '2 -16:15' DAY TO MINUTE,
  INTERVAL '1-5' YEAR TO MONTH = INTERVAL '1-5' YEAR TO MONTH,
  INTERVAL '1-5' YEAR TO MONTH > INTERVAL '2 16' DAY TO HOUR,
  INTERVAL '2-11 28 16:15:14.222' YEAR TO SECOND = INTERVAL '2-11 28 16:15:14.222' YEAR TO SECOND,
  INTERVAL '1-1 3' YEAR TO DAY = INTERVAL '13 3' MONTH TO DAY,
  INTERVAL '1-5' YEAR TO MONTH > INTERVAL '2 16' DAY TO HOUR;

Copy

Snowflake¶

SELECT
'1 year' = '1 year';

SELECT
CURRENT_DATE() + INTERVAL '-2d, -16h' = CURRENT_DATE() + INTERVAL '-2d, -16h';

SELECT
CURRENT_TIMESTAMP + INTERVAL '-2d, -16h' != CURRENT_TIMESTAMP + INTERVAL '-2d, 16h',
CURRENT_TIMESTAMP + INTERVAL '-2d, -16h' <> CURRENT_TIMESTAMP + INTERVAL '-2d, 16h',
CURRENT_TIMESTAMP + INTERVAL '2d, 16h, 15m' = CURRENT_TIMESTAMP + INTERVAL '2d, -16h, -15m',
CURRENT_TIMESTAMP + INTERVAL '2d, 16h, 15m' > CURRENT_TIMESTAMP + INTERVAL '2d, -16h, -15m',
CURRENT_TIMESTAMP + INTERVAL '2d, 16h, 15m' >= CURRENT_TIMESTAMP + INTERVAL '2d, -16h, -15m',
CURRENT_TIMESTAMP + INTERVAL '2d, 16h, 15m' < CURRENT_TIMESTAMP + INTERVAL '2d, -16h, -15m',
CURRENT_TIMESTAMP + INTERVAL '2d, 16h, 15m' <= CURRENT_TIMESTAMP + INTERVAL '2d, -16h, -15m',
CURRENT_TIMESTAMP + INTERVAL '1y, 5mm' = CURRENT_TIMESTAMP + INTERVAL '1y, 5mm',
CURRENT_TIMESTAMP + INTERVAL '1y, 5mm' > CURRENT_TIMESTAMP + INTERVAL '2d, 16h',
CURRENT_TIMESTAMP + INTERVAL '2y, 11mm, 28d, 16h, 15m, 14s, 222ms' = CURRENT_TIMESTAMP + INTERVAL '2y, 11mm, 28d, 16h, 15m, 14s, 222ms',
CURRENT_TIMESTAMP + INTERVAL '1y, 1mm, 3d' = CURRENT_TIMESTAMP + INTERVAL '13mm, 3d',
CURRENT_TIMESTAMP + INTERVAL '1y, 5mm' > CURRENT_TIMESTAMP + INTERVAL '2d, 16h';

Copy

Como é conhecido, o Snowflake só suporta um intervalo como tipo de dados em operações aritméticas, razão pela qual a função CURRENT_TIMESTAMP é adicionada a cada operando para oferecer suporte corretamente à comparação.

Problemas conhecidos¶

1. Only arithmetic operations are supported¶

Os intervalos do Snowflake têm várias limitações. Somente operações aritméticas entre DATE ou TIMESTAMP e constantes de intervalo são suportadas; qualquer outro cenário não é suportado.

2. Working with signs in the Interval data type¶

Em BigQuery, quando a subcadeia de caracteres correspondente ao ano-mês é precedida por um sinal (+ -); isso afeta tanto o ano quanto o mês. De maneira semelhante, funciona para a subcadeia de caracteres correspondente à hora; neste caso, o seguinte afeta a hora, o minuto e o segundo. Um exemplo disso é mostrado abaixo.

BigQuery¶

SELECT CURRENT_DATE + INTERVAL '-2-11 -28 -16:15:14.222' YEAR TO SECOND;

Copy

Snowflake¶

 SELECT CURRENT_DATE + INTERVAL '-2y, -11mm, -28d, -16h, -15m, -14s, -222ms';

Copy

EWIs relacionados¶

SSC-EWI-0036: Tipo de dados convertido em outro tipo de dados.
SSC-EWI-0107: Literal de intervalo não suportado no cenário atual.

JSON¶

Tipo de dados Json e usos

Descrição¶

Representa JSON, um formato leve de troca de dados. Para obter mais informações, consulte o tipo de dados BigQuery JSON.

Perigo

O tipo de dados JSON não é compatível com o Snowflake, atualmente transformado para VARIANT.

LiteraisJSON¶

 JSON 'json_formatted_data'

Copy

Para obter mais informações, consulte Literais JSON em BigQuery.

Esses literais não são compatíveis com o Snowflake, mas em vez disso a função PARSE_JSON pode ser usada para converter a expressão de entrada em um tipo json. O único ponto a levar em consideração é que esta função não pode ser usada na cláusula de valores do Snowflake, por isso ela é transformada em uma subconsulta.

Amostra de padrões da origem¶

BigQuery¶

CREATE OR REPLACE TABLE test.jsonType
(
  COL1 JSON
);

INSERT INTO test.jsonType
VALUES
  (JSON'{"name": "John", "age": 30, "city": "New York"}'), 
  (JSON'{"name": "Alice", "age": 28, "city": "San Francisco"}');  
  
SELECT * FROM test.jsonType;

SELECT JSON'{"name": "John", "age": 30, "city": "New York"}';

Copy

Snowflake¶

CREATE OR REPLACE TABLE test.jsonType
(
  COL1 VARIANT
);

INSERT INTO test.jsonType
SELECT
  PARSE_JSON('{"name": "John", "age": 30, "city": "New York"}')
UNION ALL
SELECT
  PARSE_JSON('{"name": "Alice", "age": 28, "city": "San Francisco"}');

SELECT * FROM test.jsonType;

SELECT
  PARSE_JSON('{"name": "John", "age": 30, "city": "New York"}');

Copy

STRUCT¶

Especificação de tradução para o tipo de dados STRUCT de BigQuery para Snowflake.

Descrição¶

Em BigQuery, um contêiner de campos ordenados, cada um com um tipo (obrigatório) e nome de campo (opcional). Consulte Tipo de estrutura.

No Snowflake, OBJECT_CONSTRUCT pode ser usado para emular o comportamento de STRUCT, e SnowConvert AI trata da maioria das diferenças de implementação.

Nota

Argumentos que representam chaves dentro de OBJECT_CONSTRUCT devem ser os nomes originais do STRUCT de destino. Qualquer nome especificado em um corpo da expressão STRUCT será substituído pelo nome encontrado no STRUCT de destino. A maioria dos exemplos de padrões de dados abaixo contém um exemplo de um nome que é substituído pelo nome do destino.

Amostra de padrões da origem¶

BigQuery¶

CREATE OR REPLACE TABLE test.structTypes
(
    COL1 STRUCT<sc1 INT64>,
    COL2 STRUCT<sc2 STRING(10)>,
    COL3 STRUCT<sc3 STRUCT<sc31 INT64, sc32 INT64>>,
    COL4 STRUCT<sc4 ARRAY<INT64>>,
    COL5 STRUCT<sc5 INT64, sc51 INT64>,
    COL7 STRUCT<sc7 INT64 OPTIONS(description = "A repeated STRING field"), sc71 BOOL>,
    COL8 STRUCT<sc8 INT64 NOT NULL, sc81 BOOL NOT NULL OPTIONS(description = "A repeated STRING field")>
);
    
CREATE OR REPLACE TABLE test.tuple_sample (
  COL1 STRUCT<Key1 INT64, Key2 INT64>
);

Copy

Snowflake¶

CREATE OR REPLACE TABLE test.structTypes
(
    COL1 VARIANT /*** SSC-FDM-BQ0009 - STRUCT<INT> CONVERTED TO VARIANT. SOME OF ITS USAGES MIGHT HAVE FUNCTIONAL DIFFERENCES. ***/,
    COL2 VARIANT /*** SSC-FDM-BQ0009 - STRUCT<STRING(10)> CONVERTED TO VARIANT. SOME OF ITS USAGES MIGHT HAVE FUNCTIONAL DIFFERENCES. ***/,
    COL3 VARIANT /*** SSC-FDM-BQ0009 - STRUCT<STRUCT<INT64, INT64>> CONVERTED TO VARIANT. SOME OF ITS USAGES MIGHT HAVE FUNCTIONAL DIFFERENCES. ***/,
    COL4 VARIANT /*** SSC-FDM-BQ0009 - STRUCT<> CONVERTED TO VARIANT. SOME OF ITS USAGES MIGHT HAVE FUNCTIONAL DIFFERENCES. ***/,
    COL5 VARIANT /*** SSC-FDM-BQ0009 - STRUCT<INT, INT> CONVERTED TO VARIANT. SOME OF ITS USAGES MIGHT HAVE FUNCTIONAL DIFFERENCES. ***/,
    COL7 VARIANT /*** SSC-FDM-BQ0009 - STRUCT<INT, BOOLEAN> CONVERTED TO VARIANT. SOME OF ITS USAGES MIGHT HAVE FUNCTIONAL DIFFERENCES. ***/,
    COL8 VARIANT /*** SSC-FDM-BQ0009 - STRUCT<INT, BOOLEAN> CONVERTED TO VARIANT. SOME OF ITS USAGES MIGHT HAVE FUNCTIONAL DIFFERENCES. ***/
);

CREATE OR REPLACE TABLE test.tuple_sample (
  COL1 VARIANT /*** SSC-FDM-BQ0009 - STRUCT<INT, INT> CONVERTED TO VARIANT. SOME OF ITS USAGES MIGHT HAVE FUNCTIONAL DIFFERENCES. ***/
);

Copy

Inserir tipo de dados INT em coluna STRUCT¶

BigQuery¶

INSERT INTO test.structTypes (COL1) VALUES
(STRUCT(1)), 
(STRUCT<INT64>(2)), 
(STRUCT<a INT64>(3)), 
(STRUCT<sc1 INT64>(4)), 
(STRUCT<sc1 INT64>(5));

Copy

Snowflake¶

INSERT INTO test.structTypes (COL1)
SELECT
    OBJECT_CONSTRUCT('sc1', 1 :: INT)
UNION ALL
SELECT
    OBJECT_CONSTRUCT('sc1', 2 :: INT)
UNION ALL
SELECT
    OBJECT_CONSTRUCT('sc1', 3 :: INT)
UNION ALL
SELECT
    OBJECT_CONSTRUCT('sc1', 4 :: INT)
UNION ALL
SELECT
    OBJECT_CONSTRUCT('sc1', 5 :: INT);

Copy

Inserir tipo de dados STRING em coluna STRUCT¶

BigQuery¶

INSERT INTO test.structTypes (COL2) VALUES
(STRUCT('t1')), 
(STRUCT<STRING>('t2')), 
(STRUCT<sc2 STRING>('t3'));

Copy

Snowflake¶

INSERT INTO test.structTypes (COL2)
SELECT
    OBJECT_CONSTRUCT('sc2', 't1' :: STRING)
UNION ALL
SELECT
    OBJECT_CONSTRUCT('sc2', 't2' :: STRING)
UNION ALL
SELECT
    OBJECT_CONSTRUCT('sc2', 't3' :: STRING);

Copy

Inserir tipo de dados STRUCT em coluna STRUCT¶

BigQuery¶

INSERT INTO test.structTypes (COL3) VALUES
(STRUCT(STRUCT(1,2))), 
(STRUCT<sc3 STRUCT<sc31 INT64, sc32 INT64>>(STRUCT<INT64, INT64>(3, 4))),
(STRUCT<sc3 STRUCT<sc31 INT64, sc32 INT64>>(STRUCT<sc31 INT64, sc32 INT64>(5, 6))),
(STRUCT<STRUCT<INT64,INT64>>(STRUCT<INT64, INT64>(7, 8))),
(STRUCT<STRUCT<INT64,INT64>>(STRUCT(9, 10)));

Copy

Snowflake¶

INSERT INTO test.structTypes (COL3)
SELECT
  OBJECT_CONSTRUCT('sc3', OBJECT_CONSTRUCT('sc31', 1 :: INT, 'sc32', 2 :: INT))
UNION ALL
SELECT
  OBJECT_CONSTRUCT('sc3', OBJECT_CONSTRUCT('sc31', 3 :: INT, 'sc32', 4 :: INT))
UNION ALL
SELECT
  OBJECT_CONSTRUCT('sc3', OBJECT_CONSTRUCT('sc31', 5 :: INT, 'sc32', 6 :: INT))
UNION ALL
SELECT
  OBJECT_CONSTRUCT('sc3', OBJECT_CONSTRUCT('sc31', 7 :: INT, 'sc32', 8 :: INT))
UNION ALL
SELECT
  OBJECT_CONSTRUCT('sc3', OBJECT_CONSTRUCT('sc31', 9 :: INT, 'sc32', 10 :: INT));

Copy

Inserir tipo de dados ARRAY em coluna STRUCT¶

BigQuery¶

INSERT INTO test.structTypes (COL4) VALUES
(STRUCT([1,2,3,4])), 
(STRUCT<sc4 ARRAY<INT64>>(ARRAY[5,6,7])), 
(STRUCT<ARRAY<INT64>>([8,9,10,11]));

Copy

Snowflake¶

INSERT INTO test.structTypes (COL4)
SELECT
  OBJECT_CONSTRUCT('sc4', [1,2,3,4] :: ARRAY)
UNION ALL
SELECT
  OBJECT_CONSTRUCT('sc4', [5,6,7] :: ARRAY)
UNION ALL
SELECT
  OBJECT_CONSTRUCT('sc4', [8,9,10,11] :: ARRAY);

Copy

Inserir nas colunas STRUCT selecionadas¶

BigQuery¶

INSERT INTO test.structTypes (COL7, COL8) VALUES
(STRUCT(1,true), STRUCT(2,false)), 
(STRUCT<INT64, BOOL>(3, false), STRUCT<INT64, BOOL>(4, false)), 
(STRUCT<a INT64, b BOOL>(5, true), STRUCT<a INT64, b BOOL>(6, true));

Copy

Snowflake¶

INSERT INTO test.structTypes (COL7, COL8)
SELECT
  OBJECT_CONSTRUCT('sc7', 1 :: INT, 'sc71', true),
  OBJECT_CONSTRUCT('sc8', 2 :: INT, 'sc81', false)
UNION ALL
SELECT
  OBJECT_CONSTRUCT('sc7', 3 :: INT, 'sc71', false),
  OBJECT_CONSTRUCT('sc8', 4 :: INT, 'sc81', false)
UNION ALL
SELECT
  OBJECT_CONSTRUCT('sc7', 5 :: INT, 'sc71', true),
  OBJECT_CONSTRUCT('sc8', 6 :: INT, 'sc81', true);

Copy

Inserir para sintaxe da tupla de coluna STRUCT¶

Aviso

A tradução de valores de sintaxe de tupla não é suportada atualmente.

BigQuery¶

INSERT INTO test.tuple_sample
VALUES
  ((12, 34)),
  ((56, 78)),
  ((9, 99)),
  ((12, 35));

Copy

Snowflake¶

INSERT INTO test.tuple_sample
!!!RESOLVE EWI!!! /*** SSC-EWI-BQ0012 - UNABLE TO GENERATE CORRECT OBJECT_CONSTRUCT PARAMETER. SYMBOL INFORMATION COULD NOT BE COLLECTED. ***/!!!
VALUES
  ((12, 34)),
  ((56, 78)),
  ((9, 99)),
  ((12, 35));

Copy

Atualizar coluna STRUCT¶

BigQuery¶

UPDATE test.structTypes
SET col1 = STRUCT(100 AS number)
WHERE col1.sc1 = 4;

Copy

Snowflake¶

UPDATE test.structTypes
    SET col1 = OBJECT_CONSTRUCT('sc1', 100 :: INT)
WHERE col1:sc1 = 4;

Copy

Atualizar campo de coluna STRUCT¶

BigQuery¶

UPDATE test.structTypes
SET col3 = STRUCT(STRUCT(80,90))
WHERE col3.sc3.sc31 = 20;

Copy

Snowflake¶

UPDATE test.structTypes
SET col3 = OBJECT_CONSTRUCT('sc3', OBJECT_CONSTRUCT('sc31', 80 :: INT, 'sc32', 90 :: INT))
WHERE col3:sc3:sc31 = 20;

Copy

Selecionar da coluna STRUCT¶

BigQuery¶

SELECT COL3.sc3 FROM test.structTypes;
SELECT COL3.sc3.sc32 FROM test.structTypes;
SELECT COL4.sc4 FROM test.structTypes WHERE COL4.sc4 IS NOT NULL;

Copy

Snowflake¶

SELECT COL3:sc3
FROM
test.structTypes;
SELECT COL3:sc3:sc32
FROM
test.structTypes;
SELECT COL4:sc4
FROM
test.structTypes
WHERE COL4:sc4 IS NOT NULL;

Copy

Selecionar de sintaxe da tupla de coluna STRUCT¶

BigQuery¶

SELECT *
FROM test.tuple_sample
WHERE (COL1.Key1, COL1.Key2) IN ((12, 34), (56, 78));

SELECT STRUCT<x ARRAY<INT64>, y INT64>(COL4.sc4, COL1.sc1)
FROM test.structTypes
WHERE COL1.sc1 IS NOT NULL;

Copy

Snowflake¶

SELECT *
FROM
test.tuple_sample
WHERE (COL1:Key1, COL1:Key2) IN ((12, 34), (56, 78));

SELECT
OBJECT_CONSTRUCT('x', COL4:sc4 :: ARRAY, 'y', COL1:sc1 :: INT)
FROM
test.structTypes
WHERE COL1:sc1 IS NOT  NULL;

Copy

Criação de uma exibição usando uma definição anônima STRUCT¶

BigQuery¶

CREATE OR REPLACE TABLE project-test.mydataset.sourcetable (
  id STRING,
  payload JSON
);

CREATE VIEW project-test.mydataset.myview AS 
SELECT
  id,
  STRUCT(
    payload.user_id AS user_id,
    STRUCT(
      JSON_VALUE(payload, '$.details.ip_address') AS ip_address,
      JSON_VALUE(payload, '$.details.item_id') AS item_id,
      SAFE_CAST(JSON_VALUE(payload, '$.details.quantity') AS INT64) AS quantity,
      SAFE_CAST(JSON_VALUE(payload, '$.details.price') AS FLOAT64) AS price,
      JSON_VALUE(payload, '$.details.text') AS text
    ) AS details
  ) AS structured_payload
  FROM project-test.mydataset.sourcetable;

Copy

Snowflake¶

CREATE OR REPLACE TABLE "project-test".mydataset.sourcetable (
  id STRING,
  payload VARIANT
);

CREATE VIEW "project-test".mydataset.myview
AS
SELECT
  id,
  OBJECT_CONSTRUCT('user_id',
  payload:user_id, 'details', OBJECT_CONSTRUCT('ip_address', JSON_EXTRACT_PATH_TEXT(payload, 'details.ip_address'), 'item_id', JSON_EXTRACT_PATH_TEXT(payload, 'details.item_id'), 'quantity', TRY_CAST(JSON_EXTRACT_PATH_TEXT(payload, 'details.quantity') AS INT), 'price', TRY_CAST(JSON_EXTRACT_PATH_TEXT(payload, 'details.price') AS FLOAT), 'text', JSON_EXTRACT_PATH_TEXT(payload, 'details.text'))) AS structured_payload
  FROM
  "project-test".mydataset.sourcetable;

Copy

Expressões de comparação de colunas STRUCT¶

As operações de comparação de BigQuery para Structs comparam valor com valor, ignorando a chave se ela existir, enquanto as operações de comparação de objetos do Snowflake comparam tanto o valor quanto a chave. Isso pode fazer com que algumas comparações retornem um resultado diferente.

BigQuery¶

SELECT * FROM test.structTypes WHERE COL1 NOT IN (COL2);
SELECT * FROM test.structTypes WHERE COL1 <> (COL2);
SELECT * FROM test.structTypes WHERE COL1 != (COL2);

Copy

Snowflake¶

SELECT * FROM
test.structTypes
--** SSC-FDM-BQ0008 - WHERE CLAUSE REFERENCES A COLUMN OF STRUCT TYPE. COMPARISON OPERATIONS MAY PRODUCE DIFFERENT RESULTS IN SNOWFLAKE. **
WHERE COL1 NOT IN (COL2);
SELECT * FROM
test.structTypes
--** SSC-FDM-BQ0008 - WHERE CLAUSE REFERENCES A COLUMN OF STRUCT TYPE. COMPARISON OPERATIONS MAY PRODUCE DIFFERENT RESULTS IN SNOWFLAKE. **
WHERE COL1 <> (COL2);
SELECT * FROM
test.structTypes
--** SSC-FDM-BQ0008 - WHERE CLAUSE REFERENCES A COLUMN OF STRUCT TYPE. COMPARISON OPERATIONS MAY PRODUCE DIFFERENT RESULTS IN SNOWFLAKE. **
WHERE COL1 != (COL2);

Copy

EWIs relacionados¶

SSC-FDM-BQ0010: Estrutura convertida em VARIANT. Alguns de seus usos podem ter diferenças funcionais.
SSC-EWI-BQ0012: Não é possível gerar o parâmetro OBJECT_CONSTRUCT correto.
SSC-FDM-BQ0008: A cláusula WHERE referencia uma coluna do tipo STRUCT.

TIMESTAMP¶

Tipo de dados de carimbo de data/hora e usos

Descrição¶

Um valor de carimbo de data/hora representa um ponto absoluto no tempo, independentemente de qualquer fuso horário ou convenção, como horário de verão (DST), com precisão de microssegundos. Para obter mais informações, consulte Tipo de dados BigQuery de carimbo de data/hora.

Sintaxe gramatical¶

Name	Range
TIMESTAMP	0001-01-01 00:00:00 to 9999-12-31 23:59:59.999999 UTC

Sucesso

Tipo de dados TIMESTAMP atualmente transformado em TIMESTAMP_TZ.#x20;

É importante observar que BigQuery armazena dados TIMESTAMP em Tempo Universal Coordenado (UTC).

Amostra de padrões da origem¶

TIMESTAMP sem tempo¶

BigQuery¶

 CREATE OR REPLACE TABLE timestampTable
(
  COL1 TIMESTAMP
);

INSERT INTO timestampTable VALUES ('2008-12-26 15:30:00');
INSERT INTO timestampTable VALUES (TIMESTAMP'2008-12-27 18:30:00');
SELECT * FROM timestampTable;

Copy

Resultado¶

2008-12-26 15:30:00 UTC
2008-12-27 18:30:00 UTC

Copy

Snowflake¶

CREATE OR REPLACE TABLE timestampTable
(
  COL1 TIMESTAMP_TZ
);

INSERT INTO timestampTable VALUES ('2008-12-26 15:30:00');
INSERT INTO timestampTable VALUES (TIMESTAMP'2008-12-27 18:30:00');
SELECT * FROM timestampTable;

Copy

Resultado¶

2008-12-26 15:30:00.000 -0800
2008-12-27 18:30:00.000 -0800

Copy

TIMESTAMP com fuso horário.¶

Quando o fuso horário estiver definido, você precisará usar a função CONVERT_TIMEZONE para armazenar os dados no Tempo Universal Coordenado (UTC). Além disso, o nome do fuso horário dentro do literal de carimbo de data/hora não é suportado pelo Snowflake; nesse caso, é necessário usar esta função também.

BigQuery¶

CREATE OR REPLACE TABLE test.timestampType
(
  COL1 TIMESTAMP
);

INSERT INTO test.timestampType VALUES ('2008-12-25 15:30:00 America/Chicago');
INSERT INTO test.timestampType VALUES ('2018-04-05 12:00:00+02:00');
INSERT INTO test.timestampType VALUES ('2008-12-26 15:30:00-08:00');
INSERT INTO test.timestampType VALUES (TIMESTAMP'2022-12-25 15:30:00 America/North_Dakota/New_Salem');
INSERT INTO test.timestampType VALUES (TIMESTAMP'2022-04-05 12:00:00+02:00');
INSERT INTO test.timestampType VALUES (TIMESTAMP'2022-12-26 15:30:00-08:00');
SELECT * FROM test.timestampType ORDER BY COL1;

Copy

Resultado¶

2008-12-25 21:30:00 UTC	
2008-12-26 23:30:00 UTC	
2018-04-05 10:00:00 UTC	
2022-04-05 10:00:00 UTC	
2022-12-25 21:30:00 UTC	
2022-12-26 23:30:00 UTC

Copy

Snowflake¶

CREATE OR REPLACE TABLE test.timestampType
(
  COL1 TIMESTAMP_TZ
);

INSERT INTO test.timestampType
VALUES (CONVERT_TIMEZONE('America/Chicago', 'UTC', '2008-12-25 15:30:00'));
INSERT INTO test.timestampType
VALUES (CONVERT_TIMEZONE('UTC','2018-04-05 12:00:00+02:00'));
INSERT INTO test.timestampType
VALUES (CONVERT_TIMEZONE('UTC','2008-12-26 15:30:00-08:00'));

INSERT INTO test.timestampType
VALUES (CONVERT_TIMEZONE('America/North_Dakota/New_Salem', 'UTC', '2022-12-25 15:30:00'));
INSERT INTO test.timestampType
VALUES (CONVERT_TIMEZONE('UTC', '2022-04-05 12:00:00+02:00'));
INSERT INTO test.timestampType
VALUES (CONVERT_TIMEZONE('UTC', '2022-12-26 15:30:00-08:00'));
SELECT * FROM test.timestampType ORDER BY COL1;

Copy

Resultado¶

 2008-12-25 21:30:00.000 -0800
2008-12-26 23:30:00.000 +0000
2018-04-05 10:00:00.000 +0000
2022-04-05 10:00:00.000 +0000
2022-12-25 21:30:00.000 -0800
2022-12-26 23:30:00.000 +0000

Copy

SnowConvert AI - BigQuery - Tipos de dados¶

Tipo de dado booleano¶

Tipo de dados Bytes¶

Tipos de dados de data e hora¶

Tipo de dados de geografia¶

Tipo de dados de intervalo¶

Tipo de dados Json¶

Tipos de dados numéricos¶

Tipos de dados de cadeia de caracteres¶

ANY TYPE¶

Descrição¶

Amostra de padrões da origem¶

Definição de tipo para UDFs¶

BigQuery¶

Snowflake¶

ARRAY<T>¶

Descrição¶

Amostra de padrões da origem¶

BigQuery¶

Snowflake¶

Acesso de ARRAY por índice¶

BigQuery¶

Snowflake¶

Acesso seguro de ARRAY por índice¶

BigQuery¶

Snowflake¶

INSERT com ARRAY na cláusula VALUES¶

BigQuery¶

Snowflake¶

Instrução MERGE¶

BigQuery¶

Snowflake¶

Inserção/atualização de valor de coluna ARRAY DEFAULT¶

BigQuery¶

Snowflake¶

INSERT/UPDATE com valor NULL¶

BigQuery¶

Snowflake¶

Concatenação de ARRAY¶

BigQuery¶

Snowflake¶

ARRAY usado como parâmetro/tipo de retorno¶

BigQuery¶

Snowflake¶

Problemas conhecidos¶

EWIs relacionados¶

BYTES¶

Descrição¶

Amostra de padrões da origem¶

Formato de saída BYTES¶

BigQuery¶

Snowflake:¶

Literal BYTES¶

Observações¶

GEOGRAPHY¶

Descrição¶

Amostra de padrões da origem¶

Formato de saída GEOGRAPHY¶

BigQuery¶

Snowflake¶

Inserir dados de GEOGRAPHY¶

Observações¶

EWI relacionados¶

INTERVAL¶

Descrição¶

Amostra de padrões da origem¶

Intervalo com uma única parte DateTime¶

BigQuery¶

Resultado¶

Snowflake¶

Resultado¶

Intervalo com um intervalo de partes DateTime¶

BigQuery¶

Resultado¶

Snowflake¶

Resultado¶

Intervalo como um tipo de dados de Coluna¶

BigQuery¶

Resultado¶

Snowflake¶