SnowConvert AI - BigQuery - Types de données¶

Snowflake prend en charge la majorité des principes des types de données SQL fondamentaux, avec des restrictions spécifiques, sur différentes constructions SQL, y compris les colonnes, les variables locales, les expressions et les paramètres.

Type de données booléennes¶


BigQuery	Snowflake	Remarques
BOOL/BOOLEAN	BOOLEAN

Type de données d’octets¶


BigQuery	Snowflake	Remarques
BYTES	BINARY	BYTES Le type de données n’est pas pris en charge dans Snowflake. BINARY est utilisé à la place. Pour plus d’informations, voir la documentation sur le type de données BYTES.

Types de données horodatage¶


BigQuery	Snowflake	Remarques
DATE	DATE
DATETIME	DATETIME	DATETIME est un alias pour TIMESTAMP_NTZ dans Snowflake
TIMESTAMP	TIMESTAMP_TZ	TIMESTAMP le type de données est converti en TIMESTAMP_TZ. Pour plus d’informations, voir la documentation sur le type de données TIMESTAMP.
TIME	TIME

Type de données géographiques¶


BigQuery	Snowflake	Remarques
GEOGRAPHY	GEOGRAPHY

Type de données d’intervalle¶


BigQuery	Snowflake	Remarques
INTERVAL	VARCHAR(30)	INTERVAL Le type de données n’est pas pris en charge dans Snowflake. VARCHAR est utilisé à la place. Pour plus d’informations, voir la documentation sur le type de données INTERVAL.

Type de données Json¶


BigQuery	Snowflake	Remarques
JSON	VARIANT	JSON Le type de données n’est pas pris en charge dans Snowflake. VARIANT est utilisé à la place. Pour plus d’informations, voir la documentation sur le type de données JSON.

Types de données numériques¶


BigQuery	Snowflake	Remarques
INT64	INT	INT est un alias pour le type de données NUMBER dans Snowflake. La précision et l’échelle maximales sont NUMBER(38,37).
INT	INT	INT est un alias pour le type de données NUMBER dans Snowflake. La précision et l’échelle maximales sont NUMBER(38,37).
SMALLINT	SMALLINT	SMALLINT est un alias pour le type de données NUMBER dans Snowflake. La précision et l’échelle maximales sont NUMBER(38,37).
INTEGER	INTEGER	INTEGER est un alias pour le type de données” NUMBER dans Snowflake. La précision et l’échelle maximales sont NUMBER(38,37).
BIGINT	BIGINT	BIGINT est un alias pour le type de données NUMBER dans Snowflake. La précision et l’échelle maximales sont NUMBER(38,37).
TINYINT	TINYINT	TINYINT est un alias pour le type de données NUMBER dans Snowflake. La précision et l’échelle maximales sont NUMBER(38,37).
BYTEINT	BYTEINT	BYTEINT est un alias pour le type de données NUMBER dans Snowflake. La précision et l’échelle maximales sont NUMBER(38,37).
NUMERIC	NUMERIC	NUMERIC est un alias pour le type de données NUMBER dans Snowflake. La précision et l’échelle maximales sont NUMBER(38,37).
DECIMAL	DECIMAL	DECIMAL est un alias pour le type de données NUMBER dans Snowflake. La précision et l’échelle maximales sont NUMBER(38,37).
BIGNUMERIC	NUMERIC	Snowflake ne prend pas en charge le type BIGNUMERIC. Utiliser NUMERIC à la place. La précision BIGNUMERIC, 76, dépasse la limite de Snowflake (38), ce qui entraîne une troncation ou un arrondi, ce qui peut introduire des inexactitudes importantes.
BIGDECIMAL	DECIMAL	Snowflake ne prend pas en charge le type BIGDECIMAL. Utiliser NUMERIC à la place. La précision BIGDECIMAL, 76, dépasse la limite de Snowflake (38), ce qui entraîne une troncation ou un arrondi, ce qui peut introduire des inexactitudes importantes.
FLOAT64	FLOAT

Types de données de chaîne¶


BigQuery	Snowflake	Remarques
STRING	STRING	STRING est un alias pour le type de données VARCHAR dans Snowflake. VARCHAR contient UTF-8 caractères Unicode.

ANY TYPE¶

Spécification de traduction pour le type de données BigQuery ANY TYPE

Description¶

Ce qui suit est un extrait d’informations sur l’utilisation de ANY TYPE dans les instructions CREATE FUNCTION.

Un paramètre dont le type est égal à ANY TYPE peut correspondre à plusieurs types d’arguments lorsque la fonction est appelée.

Si plusieurs paramètres sont de type ANY TYPE, BigQuery n’impose aucune relation de type entre ces arguments.

Le type de renvoi de la fonction ne peut pas être ANY TYPE. Il doit être omis, ce qui signifie qu’il sera automatiquement déterminé en fonction de expression_sql ou d’un type explicite.

La transmission d’arguments de fonction de types incompatibles avec la définition de la fonction entraîne une erreur au moment de l’appel.

Modèles d’échantillons de sources¶

Définition de type pour les UDFs¶

ANY TYPE ne peut être trouvé que comme type de paramètre d’une fonction. SnowConvert AI traduit automatiquement ANY TYPE en VARIANT.

BigQuery¶

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

Snowflake¶

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

ARRAY<T>¶

Spécification de traduction pour le type de données ARRAY de BigQuery vers Snowflake

Description¶

Dans BigQuery, un tableau est une liste ordonnée de zéro ou plusieurs éléments de valeurs non tabulaires. Les éléments d’un tableau doivent partager le même type. (Type de tableau. BigQuery)

Modèles d’échantillons de sources¶

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]);

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];

Accès ARRAY par index¶

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];

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];

Accès ARRAY sécurisé par index¶

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];

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];

INSERT avec ARRAY dans la clause 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];

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];

instruction 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];

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];

Insertion/mise à jour de la valeur de colonne ARRAY DEFAULT¶

BigQuery¶

 INSERT INTO test.arrayTable VALUES (DEFAULT);

UPDATE test.arrayTable
SET col1 = DEFAULT
WHERE TRUE;

SELECT col1 FROM test.arrayTable;

Snowflake¶

 INSERT INTO test.arrayTable SELECT [];

UPDATE test.arrayTable
SET col1 = DEFAULT
WHERE TRUE;

SELECT col1 FROM test.arrayTable;

INSERT/UPDATE avec valeur 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);

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);

Concaténation ARRAY¶

BigQuery¶

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

Snowflake¶

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

ARRAY utilisé comme type de paramètre/de retour¶

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;

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;

Problèmes connus¶

1. L’accès ARRAY non sécurisé n’échouera pas pour les index positifs hors limites

Dans BigQuery, l’accès à un élément de tableau par index échouera pour toute valeur d’index trop faible (sous-flux) ou trop élevée (débordement) en cas de non-utilisation de SAFE_OFFSET ou SAFE_ORDINAL. Cependant, dans Snowflake les erreurs ne sont générées que pour les cas de sous-flux, en revanche, tout index qui causerait une erreur de débordement générera une valeur NULL.

Lorsqu’un accès non sécurisé aux éléments d’un tableau est détecté SnowConvert AI générera SSC-FDM-BQ0001 pour avertir l’utilisateur.

BYTES¶

Type de données d’octets et utilisations de ce type de données

Description¶

Séquence d’octets avec un maximum de L octets autorisés dans la chaîne binaire. La longueur maximale est de 8 MB (8 388 608 octets). Pour plus d’informations, reportez-vous au type de données BigQuery BYTES.

Note

Le type de données BYTES n’est pas pris en charge dans Snowflake, actuellement transformé en BINARY.#x20;

Modèles d’échantillons de sources¶

Format des résultats du type de données BYTES¶

Le format de sortie par défaut pour les types de données binaires dans BigQuery est “BASE64” et “HEX” dans Snowflake. Pour cette raison, lorsqu’une colonne binaire est sélectionnée, la fonction BASE64_ENCODE est automatiquement ajoutée. Afin de maintenir le formatage par défaut des 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;

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;

Dans le cas où elles ne sont pas ajoutées automatiquement et que vous souhaitez voir les données dans le format BASE64, vous pouvez utiliser la fonction BASE64_ENCODE ou définir la fonction BINARY_OUTPUT_FORMAT.

Littéral BYTES¶

Les cas suivants représentent les formes qui peuvent être utilisées pour formater les littéraux d’octets en BigQuery.

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

Ces littéraux ne sont pas pris en charge dans Snowflake, mais la fonction TRY_TO_BINARY peut être utilisée pour convertir l’expression d’entrée en valeur binaire. La fonction est une version spéciale de TO_BINARY qui effectue la même opération, mais avec une prise en charge du traitement des erreurs.

Il est important de tenir compte du fait que le format binaire pour la conversion peut être : HEX, BASE64 ou UTF-8. La valeur par défaut est la valeur du paramètre de session BINARY_INPUT_FORMAT. Si ce paramètre n’est pas défini, la valeur par défaut est HEX.

Considérations¶

Veuillez garder à l’esprit que le format de sortie par défaut pour les types de données binaires dans BigQuery est “BASE64” et “HEX” dans Snowflake. Vous pouvez utiliser la fonction BASE64_ENCODE ou appliquer le format BINARY_OUTPUT_FORMAT si vous souhaitez voir les données dans le format BASE64.
Les seuls formats pris en charge par Snowflake sont les suivants : HEX, BASE64 ou UTF-8. Pour plus d’informations, veuillez vous référer à Entrée et sortie binaire dans Snowflake.
Les fonctions binaires utilisées pour insérer des données dans une clause de valeurs ne sont pas prises en charge dans Snowflake.

GEOGRAPHY¶

Type de données GEOGRAPHY et utilisations de ce type de données

Description¶

Un ensemble de points, de chaînes de lignes et de polygones, représenté par un ensemble de points ou un sous-ensemble de la surface de la Terre. Pour plus d’informations, reportez-vous au type de données BigQuery GEOGRAPHY.

Succès

Type de données pris en charge dans Snowflake.

Modèles d’échantillons de sources¶

Format des résultats du type de données GEOGRAPHY¶

Le format de sortie par défaut pour les types de données géographiques dans BigQuery est WKT (texte bien connu) et dans Snowflake WKB (binaire bien connu). Pour cette raison, lorsque des colonnes géographiques sont sélectionnées, la fonction ST_ASWKT est automatiquement ajoutée. De plus, lorsque toutes les colonnes d’une table sont sélectionnées et que la table contient une colonne Géographie, le format GEOGRAPHY_OUTPUT_FORMAT est défini sur WKT. Afin de conserver le format par défaut 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;	

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;

Dans le cas où les données ne sont pas ajoutées automatiquement et que vous souhaitez les voir dans le format WKT, vous pouvez utiliser la fonction ST_ASWKT ou appliquer le format GEOGRAPHY_OUTPUT_FORMAT.

Insérer des données GEOGRAPHY¶

Pour insérer des données dans des colonnes de type géographique, aucune fonction n’est nécessaire, car Snowflake détecte automatiquement que les données suivent la norme 84 WGS.

Considérations¶

N’oubliez pas que le format de sortie par défaut pour les types de données géographiques est le suivant : WKT (texte bien connu) et dans Snowflake WKB (binaire bien connu). Vous pouvez utiliser la fonction ST_ASWKT ou appliquer le format GEOGRAPHY_OUTPUT_FORMAT si vous souhaitez afficher les données dans le format WKT.
Les fonctions de géographie utilisées pour insérer des données dans une clause de valeurs ne sont pas nécessaires dans Snowflake.

EWIs connexes¶

SSC-FDM-BQ0010: La fonction géographique n’est pas requise dans Snowflake.

INTERVAL¶

Type de données d’intervalle et utilisations de ce type de données

Description¶

Un objet INTERVAL représente la durée, sans faire référence à un point spécifique dans le temps. Il n’y a pas d’équivalent dans Snowflake donc il est transformé en Varchar (Référence linguistique BigQuery Type de données INTERVAL)

Syntaxe

INTERVAL int64_expression datetime_part

INTERVAL datetime_parts_string starting_datetime_part TO ending_datetime_part

Modèles d’échantillons de sources¶

Intervalle avec un seule partie 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;

Résultat¶

1-0 0 0:0:0

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

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';

Résultat¶

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

Snowflake ne prend pas en charge le scénario dans lequel le type de données Intervalle est interrogé directement, au contraire lorsqu’il est utilisé comme opérateur pour une date donnée sa traduction est effectuée à l’aide d’une [constante d’intervalle](https://docs. snowflake.com/en/sql-reference/data-types-datetime.html#interval-constants) (si possible).

Intervalle avec une plage de parties 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;

Résultat¶

2-1 10 0:0:0

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

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';

Résultat¶

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

La valeur d’intervalle est transformée dans un format Snowflake pris en charge, puis insérée sous forme de texte dans la colonne. Comme Snowflake ne prend pas en charge l”intervalle comme type de données, il n’est pris en charge que dans les opérations arithmétiques. Pour utiliser la valeur, il faut l’extraire et l’utiliser comme constante d’intervalle (si possible).

Intervalle comme type de données de colonne¶

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;

Résultat¶


ID	colonne_intervalle
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;

Résultat¶


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

Dans BigQuery la partie horodatage (datetime_part) suit le format canonique suivant :

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

Comparaison d’intervalle¶

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;

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';

Il est connu que Snowflake ne prend en charge que l’intervalle comme type de données dans les opérations arithmétiques, d’où la raison pour laquelle la fonction CURRENT_TIMESTAMP est ajoutée à chaque opérande pour prendre en charge correctement la comparaison.

Problèmes connus¶

1. Only arithmetic operations are supported¶

Les intervalles Snowflake ont plusieurs limites. Seules les opérations arithmétiques entre DATE ou TIMESTAMP et les constantes d’intervalle sont pris en charge ; tous les autres scénarios ne sont pas pris en charge.

2. Working with signs in the Interval data type¶

Dans BigQuery, lorsque la sous-chaîne correspondant à l’année-mois est précédée d’un signe (+ -), elle affecte à la fois l’année et le mois. De la même manière, cela fonctionne pour la sous-chaîne correspondant à l’heure. Dans ce cas, ce qui suit affecte l’heure, la minute et la seconde. En voici un exemple.

BigQuery¶

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

Snowflake¶

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

EWIs connexes¶

SSC-EWI-0036 : Type de données converti en un autre type de données.
SSC-EWI-0107 : intervalle littéral non pris en charge dans le scénario actuel.

JSON¶

Type de données JSON et utilisations de ce type de données

Description¶

Représente JSON, un format d’échange de données léger. Pour plus d’informations, reportez-vous à Type de donnéesBigQuery JSON.

Danger

Le type de données JSON n’est pas pris en charge dans Snowflake, actuellement transformé en VARIANT.

Littéraux JSON¶

 JSON 'json_formatted_data'

Pour plus d’informations, reportez-vous à Littéraux JSON dans BigQuery.

Ces littéraux ne sont pas pris en charge dans Snowflake, mais au lieu de cela, la fonction PARSE_JSON peut être utilisée pour convertir l’expression d’entrée en type json. Le seul point à prendre en considération est que cette fonction ne peut pas être utilisée dans la clause Valeurs de Snowflake, pour cette raison elle est transformée en une sous-requête.

Modèles d’échantillons de sources¶

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"}';

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"}');

STRUCT¶

Spécification de traduction pour le type de données STRUCT de BigQuery vers Snowflake.

Description¶

Dans BigQuery, un conteneur de champs ordonnés chacun avec un type (obligatoire) et un nom de champ (facultatif). Voir Type de structure.

Dans Snowflake, OBJECT_CONSTRUCT peut être utilisé pour émuler le comportement STRUCT et SnowConvert AI traite la plupart des différences d’implémentation.

Note

Les arguments qui représentent des clés dans OBJECT_CONSTRUCT doivent être les noms d’origine de la cible STRUCT. Tout nom spécifié dans un corps d’expression STRUCT sera remplacé par le nom trouvé dans la cible STRUCT. La plupart des exemples de modèles de données ci-dessous contiennent un exemple de nom qui est remplacé par le nom cible.

Modèles d’échantillons de sources¶

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>
);

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. ***/
);

Insérer le type de données INT dans la colonne 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));

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);

Insérer le type de données STRING dans la colonne STRUCT¶

BigQuery¶

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

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);

Insérer le type de données STRUCT dans la colonne 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)));

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));

Insérer le type de données ARRAY dans la colonne 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]));

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);

Insérer dans les colonnes sélectionnées STRUCT¶

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));

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);

Insérer dans la syntaxe de tuple de colonne STRUCT¶

Avertissement

La traduction des valeurs de la syntaxe de tuple n’est actuellement pas prise en charge.

BigQuery¶

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

Snowflake¶

INSERT INTO test.tuple_sample
!!!RESOLVE EWI!!! /*** SSC-EWI-BQ0012 - SNOWCONVERT AI WAS UNABLE TO GENERATE A CORRECT OBJECT_CONSTRUCT PARAMETER. MISSING SYMBOL INFORMATION. ***/!!!
VALUES
  ((12, 34)),
  ((56, 78)),
  ((9, 99)),
  ((12, 35));

Mettre à jour la colonne STRUCT¶

BigQuery¶

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

Snowflake¶

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

Mettre à jour le champ de colonne STRUCT¶

BigQuery¶

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

Snowflake¶

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

Sélectionner depuis la colonne 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;

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;

Sélectionner depuis la syntaxe de tuple de colonne 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;

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;

Créer une vue à l’aide d’une définition anonyme 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;

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;

Expressions de comparaison de colonnes STRUCT¶

Les opérations de comparaison BigQuery pour les Structs comparent chaque valeur à chaque valeur, en ignorant la clé si elle existe, tandis que les opérations de comparaison dans Snowflake pour les Objets comparent les deux, valeur et clé. Par conséquent, certaines comparaisons peuvent renvoyer un résultat différent.

BigQuery¶

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

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);

EWIs connexes¶

SSC-FDM-BQ0010: Struct converti en VARIANT. Certaines de ses utilisations peuvent présenter des différences fonctionnelles.
SSC-EWI-BQ0012: SnowConvert AI was unable to generate a correct OBJECT_CONSTRUCT parameter. Missing symbol information.
SSC-FDM-BQ0008: Où la clause fait référence à une colonne de type STRUCT.

TIMESTAMP¶

Type de données TIMESTAMP (horodatage) et utilisations de ce type de données

Description¶

Une valeur d’horodatage représente un point absolu dans le temps, indépendamment de tout fuseau horaire ou convention tel que l’heure d’été (DST), avec une précision de l’ordre de la microseconde. Pour plus d’informations, reportez-vous à Type de données d’horodatage BigQuery.

Syntaxe grammaticale¶

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

Succès

Type de données TIMESTAMP actuellement transformé en TIMESTAMP_TZ.#x20;

Il est important de noter que BigQuery stocke les données TIMESTAMP en temps universel coordonné (UTC).

Modèles d’échantillons de sources¶

TIMESTAMP sans heure¶

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;

Résultat¶

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

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;

Résultat¶

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

TIMESTAMP avec fuseau horaire.¶

Lorsque le fuseau horaire est défini, vous devez utiliser la fonction CONVERT_TIMEZONE pour stocker les données en temps universel coordonné (UTC). Le nom du fuseau horaire dans le littéral d’horodatage n’est pas pris en charge par Snowflake, dans ce cas il est également nécessaire d’utiliser cette fonction.

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;

Résultat¶

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

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;

Résultat¶

 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