SnowConvert AI – BigQuery – Datentypen¶

Snowflake bietet Unterstützung für die meisten grundlegenden SQL-Datentypen (mit spezifischen Einschränkungen) für verschiedene SQL-Konstrukte mit Spalten, lokalen Variablen, Ausdrücken und Parametern.

Boolescher Datentyp¶


BigQuery	Snowflake	Anmerkungen
BOOL/BOOLEAN	BOOLEAN

Bytes-Datentyp¶


BigQuery	Snowflake	Anmerkungen
BYTES	BINARY	Der BYTES-Datentyp wird in Snowflake nicht unterstützt. Stattdessen wird BINARY verwendet. Weitere Informationen dazu finden Sie in der Dokumentation zum BYTES-Datentyp.

Datetime-Datentypen¶


BigQuery	Snowflake	Anmerkungen
DATE	DATE
DATETIME	DATETIME	DATETIME ist ein Alias für TIMESTAMP_NTZ in Snowflake.
TIMESTAMP	TIMESTAMP_TZ	Der TIMESTAMP-Datentyp wird in TIMESTAMP_TZ konvertiert. Weitere Informationen dazu finden Sie in der Dokumentation zum TIMESTAMP-Datentyp.
TIME	TIME

Geography-Datentyp¶


BigQuery	Snowflake	Anmerkungen
GEOGRAPHY	GEOGRAPHY

Interval-Datentyp¶


BigQuery	Snowflake	Anmerkungen
INTERVAL	VARCHAR(30)	Der INTERVAL-Datentyp wird in Snowflake nicht unterstützt. Stattdessen wird VARCHAR verwendet. Weitere Informationen dazu finden Sie in der Dokumentation zum INTERVAL-Datentyp.

JSON-Datentyp¶


BigQuery	Snowflake	Anmerkungen
JSON	VARIANT	Der JSON-Datentyp wird in Snowflake nicht unterstützt. Stattdessen wird VARIANT verwendet. Weitere Informationen dazu finden Sie in der Dokumentation zum JSON-Datentyp.

Numerische Datentypen¶


BigQuery	Snowflake	Anmerkungen
INT64	INT	INT ist ein Alias für den NUMBER-Datentyp in Snowflake. Die maximale Genauigkeit und Skalierung ist NUMBER(38,37).
INT	INT	INT ist ein Alias für den NUMBER-Datentyp in Snowflake. Die maximale Genauigkeit und Skalierung ist NUMBER(38,37).
SMALLINT	SMALLINT	SMALLINT ist ein Alias für den NUMBER-Datentyp in Snowflake. Die maximale Genauigkeit und Skalierung ist NUMBER(38,37).
INTEGER	INTEGER	INTEGER ist ein Alias für den NUMBER-Datentyp in Snowflake. Die maximale Genauigkeit und Skalierung ist NUMBER(38,37).
BIGINT	BIGINT	BIGINT ist ein Alias für den NUMBER-Datentyp in Snowflake. Die maximale Genauigkeit und Skalierung ist NUMBER(38,37).
TINYINT	TINYINT	TINYINT ist ein Alias für den NUMBER-Datentyp in Snowflake. Die maximale Genauigkeit und Skalierung ist NUMBER(38,37).
BYTEINT	BYTEINT	BYTEINT ist ein Alias für den NUMBER-Datentyp in Snowflake. Die maximale Genauigkeit und Skalierung ist NUMBER(38,37).
NUMERIC	NUMERIC	NUMERIC ist ein Alias für den NUMBER-Datentyp in Snowflake. Die maximale Genauigkeit und Skalierung ist NUMBER(38,37).
DECIMAL	DECIMAL	DECIMAL ist ein Alias für den NUMBER-Datentyp in Snowflake. Die maximale Genauigkeit und Skalierung ist NUMBER(38,37).
BIGNUMERIC	NUMERIC	Snowflake unterstützt den BIGNUMERIC-Datentyp nicht. Verwenden Sie stattdessen NUMERIC. Die Genauigkeit von 76,76 von BIGNUMERIC überschreitet die Beschränkung von Snowflake (38), was zu Abschneidungen oder Rundungen führt, was wiederum zu erheblichen Ungenauigkeiten führen kann.
BIGDECIMAL	DECIMAL	Snowflake unterstützt den BIGDECIMAL-Datentyp nicht. Verwenden Sie stattdessen NUMERIC. Die Genauigkeit von 76,76 von BIGDECIMAL überschreitet die Beschränkung von Snowflake (38), was zu Abschneidungen oder Rundungen führt, was wiederum zu erheblichen Ungenauigkeiten führen kann.
FLOAT64	FLOAT

String-Datentypen¶


BigQuery	Snowflake	Anmerkungen
STRING	STRING	STRING ist ein Alias für den VARCHAR-Datentyp in Snowflake. VARCHAR umfasst Unicode UTF-8-Zeichen.

ANY-TYPE¶

Übersetzungsspezifikation für den ANY TYPE-Datentyp von BigQuery.

Beschreibung¶

Im Folgenden finden Sie einen Auszug von Informationen zur Verwendung von ANY TYPE innerhalb von CREATE FUNCTION-Anweisungen.

Ein Parameter mit dem Typ, der gleich ANY TYPE ist, kann mit mehr als einem Argumenttyp übereinstimmen, wenn die Funktion aufgerufen wird.

Wenn mehr als ein Parameter den Typ ANY TYPE aufweist, dann erzwingt BigQuery keine Typbeziehung zwischen diesen Argumenten.

Der Rückgabetyp der Funktion darf nicht ANY TYPE sein. Sie muss entweder weggelassen werden, was bedeutet, dass sie automatisch auf der Grundlage von sql_expression oder einem expliziten Typ bestimmt wird.

Die Übergabe von Funktionsargumenten von Typen, die mit der Funktionsdefinition nicht kompatibel sind, führt zum Zeitpunkt des Aufrufs zu einem Fehler.

Beispielhafte Quellcode-Muster¶

Typdefinition für UDFs¶

ANY TYPE kann nur als Typ für den Parameter einer Funktion gefunden werden. SnowConvert AI übersetzt ANY TYPE automatisch in 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>¶

Übersetzungsspezifikation für den ARRAY-Datentyp von BigQuery in Snowflake

Beschreibung¶

In BigQuery ist ein Array eine geordnete Liste von null oder mehr Elementen, die keine Array-Werte sind. Elemente in einem Array müssen denselben Typ haben. (Array-Typ. BigQuery)

Beispielhafte Quellcode-Muster¶

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

ARRAY-Zugriff über 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];

Sicherer ARRAY-Zugriff über 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 mit ARRAY in der VALUES-Klausel¶

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

MERGE-Anweisung¶

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

Einfügen/Aktualisieren des ARRAY DEFAULT-Spaltenwerts¶

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 mit NULL-Wert¶

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

ARRAY-Verkettung¶

BigQuery¶

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

Snowflake¶

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

ARRAY verwendet als Parameter/Rückgabetyp¶

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;

Bekannte Probleme¶

1. Nicht sicherer ARRAY-Zugriff schlägt nicht fehl für positive Out-of-Bounds-Indizes

In BigQuery schlägt der Zugriff auf ein Array-Element über den Index für jeden Indexwert fehl, der zu niedrig (Unterlauf) oder zu hoch (Überlauf) ist, wenn SAFE_OFFSET oder SAFE_ORDINAL nicht verwendet wird. In Snowflake werden Fehler jedoch nur bei Unterlauffällen ausgelöst. Jeder Index, der einen Überlauffehler auslösen würde, generiert stattdessen einen NULL-Wert.

Wenn ein nicht sicherer Zugriff auf Elemente in einem Array erkannt wird, generiert SnowConvert AI SSC-FDM-BQ0001, um Benutzende darüber zu warnen.

BYTES¶

Bytes-Datentyp und Nutzung

Beschreibung¶

Sequenz von Bytes mit maximal L zulässigen Bytes in der binären Zeichenfolge. Die maximale Länge beträgt 8 MB (8.388.608 Bytes). Weitere Informationen dazu finden Sie unter BigQuery – BYTES-Datentyp.

Bemerkung

Der BYTES-Datentyp wird in Snowflake nicht unterstützt; derzeit wird der in BINARY transformiert.

Beispielhafte Quellcode-Muster¶

BYTES-Ausgabeformat¶

Das Standardausgabeformat für binäre Datentypen in BigQuery ist ‚BASE64‘ und in Snowflake ‚HEX‘. Aus diesem Grund wird bei Auswahl einer binären Spalte die BASE64_ENCODE-Funktion automatisch hinzugefügt. Um die Standardformatierung von BigQuery beizubehalten.

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;

Falls es nicht automatisch hinzugefügt wird und Sie die Daten im BASE64-Format sehen möchten, können Sie die BASE64_ENCODE-Funktion verwenden oder das Format BINARY_OUTPUT_FORMAT festlegen.

BYTES-Literal¶

Die folgenden Fälle stellen die Formen dar, die zur Formatierung von Byte-Literalen in BigQuery verwendet werden können.

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

Diese Literale werden in Snowflake nicht unterstützt, aber stattdessen kann die TRY_TO_BINARY-Funktion verwendet werden, um den Eingabeausdruck in einen Binärwert zu konvertieren. Diese Funktion ist eine spezielle Version von TO_BINARY, die die gleiche Operation ausführt, aber mit Unterstützung für die Fehlerbehandlung.

Es ist wichtig zu berücksichtigen, dass das Binärformat für die Konvertierung HEX, BASE64 oder UTF-8 sein kann. Der Standardwert ist der Wert des BINARY_INPUT_FORMAT-Sitzungsparameters. Wenn dieser Parameter nicht festgelegt ist, ist der Standardwert HEX.

Beobachtungen¶

Beachten Sie, dass das Standardausgabeformat für binäre Datentypen in BigQuery ‚BASE64‘ und in Snowflake ‚HEX‘ ist. Sie können die BASE64_ENCODE-Funktion verwenden oder das BINARY_OUTPUT_FORMAT-Format festlegen, wenn Sie die Daten im BASE64-Format anzeigen möchten.
Die einzigen von Snowflake unterstützten Formate sind: HEX, BASE64 oder UTF-8. Weitere Informationen dazu finden Sie unter Binäreingabe und -ausgabe in Snowflake.
Binäre Funktionen, die zum Einfügen von Daten in eine VALUES-Klausel verwendet werden, werden von Snowflake nicht unterstützt.

GEOGRAPHY¶

GEOGRAPHY-Datentyp und Nutzung

Beschreibung¶

Eine Sammlung von Punkten, Polygonzügen (LineStrings) und Polygonen, die als Punktmenge oder als Teilmenge der Erdoberfläche dargestellt wird. Weitere Informationen dazu finden Sie unter BigQuery – GEOGRAPHY-Datentyp.

Success

Unterstützter Datentyp in Snowflake.

Beispielhafte Quellcode-Muster¶

GEOGRAPHY-Ausgabeformat¶

Das Standardausgabeformat für geografische Datentypen in BigQuery ist WKT (Well-Known Text) und in Snowflake WKB (Well-Known Binary). Aus diesem Grund wird bei der Auswahl von Geography-Spalten die ST_ASWKT-Funktion automatisch hinzugefügt. Wenn alle Spalten einer Tabelle ausgewählt sind und sie eine Geography-Spalte enthält, wird GEOGRAPHY_OUTPUT_FORMAT auf WKT eingestellt. Dies dient dazu, das BigQuery-Standardformat beizubehalten.

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;

Falls es nicht automatisch hinzugefügt wird und Sie die Daten im WKT-Format sehen möchten, können Sie die ST_ASWKT-Funktion verwenden oder das Format GEOGRAPHY_OUTPUT_FORMAT festlegen.

GEOGRAPHY-Daten einfügen¶

Um Daten in Spalten vom Typ Geography einzufügen, wird keine Funktion benötigt, da Snowflake automatisch erkennt, dass die Daten dem WGS 84-Standard entsprechen.

Beobachtungen¶

Beachten Sie, dass das Standardausgabeformat für geografische Datentypen WKT (Well-Known Text) und in Snowflake WKB (Well-Known Binary) ist. Sie können das ST_ASWKT-Funktion verwenden oder das GEOGRAPHY_OUTPUT_FORMAT-Format festlegen, wenn Sie die Daten im WKT-Format anzeigen möchten.
Geography-Funktionen, die zum Einfügen von Daten in eine VALUES-Klausel verwendet werden, werden in Snowflake nicht benötigt.

Zugehörige EWIs¶

SSC-FDM-BQ0010: Die Geography-Funktion ist in Snowflake nicht erforderlich.

INTERVAL¶

Interval-Datentyp und Nutzung

Beschreibung¶

Ein INTERVAL-Objekt steht für die Dauer oder den Zeitraum, ohne sich auf einen bestimmten Zeitpunkt zu beziehen. Es gibt kein Äquivalent in Snowflake, daher wird es in Varchar umgewandelt (BigQuery-Sprachreferenz – INTERVAL-Datentyp).

Syntax

INTERVAL int64_expression datetime_part

INTERVAL datetime_parts_string starting_datetime_part TO ending_datetime_part

Beispielhafte Quellcode-Muster¶

Intervall mit einem einzelnen DateTime-Teil¶

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;

Ergebnis¶

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

Ergebnis¶

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 unterstützt nicht das Szenario, bei dem der Interval-Datentyp direkt abgefragt wird. Wird er hingegen als Operator für ein bestimmtes Datum verwendet, erfolgt die Übersetzung mithilfe einer Intervallkonstante (falls möglich).

Intervall mit einem DateTime-Teilbereich¶

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;

Ergebnis¶

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

Ergebnis¶

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

Der Intervallwert wird in ein unterstütztes Snowflake-Format umgewandelt und dann als Text in die Spalte eingefügt. Da Snowflake Interval als Datentyp nicht unterstützt, wird es nur in arithmetischen Operationen unterstützt. Um den Wert verwenden zu können, muss er extrahiert und als Intervallkonstante verwendet werden (wenn möglich).

Interval als Column-Datentyp¶

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;

Ergebnis¶


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;

Ergebnis¶


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

In BigQuery folgt datetime_part dem nächsten kanonischen Format:

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

Intervallvergleich¶

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

Bekanntlich unterstützt Snowflake bei arithmetischen Operationen nur „Interval“ als Datentyp. Deshalb wird jedem Operanden die CURRENT_TIMESTAMP-Funktion hinzugefügt, um den Vergleich korrekt zu ermöglichen.

Bekannte Probleme¶

1. Only arithmetic operations are supported¶

Snowflake-Intervalle unterliegen mehreren Einschränkungen. Nur arithmetische Operationen zwischen DATE oder TIMESTAMP und Intervallkonstanten werden unterstützt; alle anderen Szenarien werden nicht unterstützt.

2. Working with signs in the Interval data type¶

Wenn in BigQuery vor der Teilzeichenfolge, die dem Jahr und Monat entspricht, ein Zeichen (+ -) vorangestellt wird, wirkt sich dies sowohl auf das Jahr als auch auf den Monat aus. In ähnlicher Weise funktioniert dies für die Teilzeichenfolge, die der Zeit entspricht. In diesem Fall wirkt sich das Folgende auf Stunde, Minute und Sekunde aus. Ein Beispiel hierfür ist unten dargestellt.

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

Zugehörige EWIs¶

[SSC-EWI-0036](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/generalEWI. md#ssc-ewi-0036): Datentyp in einen anderen Datentyp konvertiert.
[SSC-EWI-0107](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/generalEWI. md#ssc-ewi-0107): Intervall-Literal wird im aktuellen Szenario nicht unterstützt.

JSON¶

JSON-Datentyp und Nutzung

Beschreibung¶

Repräsentiert JSON, ein einfaches Datenaustauschformat. Weitere Informationen dazu finden Sie unter BigQuery – JSON-Datentyp.

Gefahr

Der JSON-Datentyp wird in Snowflake nicht unterstützt; derzeit wird der in VARIANT transformiert.

JSON-Literale¶

 JSON 'json_formatted_data'

Weitere Informationen dazu finden Sie unter JSON-Literale in BigQuery.

Diese Literale werden in Snowflake nicht unterstützt, aber stattdessen kann die PARSE_JSON-Funktion verwendet werden, um den Eingabeausdruck in einen JSON-Typ zu konvertieren. Der einzige Punkt, der berücksichtigt werden muss, ist, dass diese Funktion nicht in der VALUES-Klausel von Snowflake verwendet werden kann. Aus diesem Grund wird sie in eine Unterabfrage umgewandelt.

Beispielhafte Quellcode-Muster¶

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¶

Übersetzungsspezifikation für den STRUCT-Datentyp von BigQuery in Snowflake

Beschreibung¶

In BigQuery, ein Container von geordneten Feldern, jeweils mit einem Typ (erforderlich) und einem Feldnamen (optional). Siehe STRUCT-Typ.

In Snowflake kann OBJECT_CONSTRUCT verwendet werden, um das STRUCT-Verhalten zu emulieren und SnowConvert AI handhabt die meisten Implementierungsunterschiede.

Bemerkung

Argumente, die Schlüssel innerhalb von OBJECT_CONSTRUCT darstellen, müssen die ursprünglichen Namen des Ziel-STRUCT sein. Jeder Name, der in einem Textteil des STRUCT-Ausdrucks angegeben ist, wird durch den Namen ersetzt, der im Ziel-STRUCT gefunden wird. Die meisten der unten aufgeführten Beispiele für Datenmuster enthalten ein Beispiel für einen Namen, der durch den Zielnamen ersetzt wird.

Beispielhafte Quellcode-Muster¶

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

INT-Datentyp in STRUCT-Spalte einfügen¶

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

STRING-Datentyp in STRUCT-Spalte einfügen¶

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

STRUCT-Datentyp in STRUCT-Spalte einfügen¶

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

ARRAY-Datentyp in STRUCT-Spalte einfügen¶

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

In ausgewählte STRUCT-Spalten einfügen¶

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

In STRUCT-Spalten-Tupel-Syntax einfügen¶

Warnung

Die Übersetzung von Tupel-Syntax-Werten wird derzeit nicht unterstützt.

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

STRUCT-Spalte aktualisieren¶

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;

STRUCT-Spaltenfeld aktualisieren¶

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;

Aus STRUCT-Spalte auswählen¶

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;

Aus STRUCT-Spalten-Tupel-Syntax auswählen¶

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;

Ansicht mit einer anonymen STRUCT-Definition erstellen¶

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;

Vergleichsausdrücke für STRUCT-Spalten¶

BigQuery-Vergleichsoperationen für Structs vergleichen Wert mit Wert und ignorieren den Schlüssel, falls er existiert, während Snowflake-Vergleichsoperationen für Objekte sowohl den Wert als auch den Schlüssel vergleichen. Dies kann dazu führen, dass einige Vergleiche ein anderes Ergebnis liefern.

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

Zugehörige EWIs¶

SSC-FDM-BQ0010: Struct, das in VARIANT konvertiert wurde. Einige der Verwendungen können funktionale Unterschiede aufweisen.
SSC-EWI-BQ0012: SnowConvert AI was unable to generate a correct OBJECT_CONSTRUCT parameter. Missing symbol information.
SSC-FDM-BQ0008: Klausel verweist hierbei auf eine Spalte vom STRUCT-Typ.

TIMESTAMP¶

Timestamp-Datentyp und Nutzung

Beschreibung¶

Ein Zeitstempelwert stellt einen absoluten Zeitpunkt dar, unabhängig von Zeitzonen oder Konventionen wie der Sommerzeit (DST), mit Mikrosekundengenauigkeit. Weitere Informationen dazu finden Sie unter BigQuery – Timestamp-Datentyp.

Grammatikalische Syntax¶

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

Success

TIMESTAMP-Datentyp, der derzeit in TIMESTAMP_TZ umgewandelt wird.

Es ist wichtig zu erwähnen, dass BigQuery TIMESTAMP-Daten in koordinierter Weltzeit (Coordinated Universal Time, UTC) speichert.

Beispielhafte Quellcode-Muster¶

TIMESTAMP ohne Uhrzeit¶

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;

Ergebnis¶

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;

Ergebnis¶

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

TIMESTAMP mit Zeitzone¶

Wenn die Zeitzone definiert ist, müssen Sie die CONVERT_TIMEZONE-Funktion zum Speichern der Daten in koordinierter Weltzeit (UTC) verwenden. Auch der Zeitzonenname im Zeitstempelliteral wird von Snowflake nicht unterstützt. In diesem Fall muss auch diese Funktion verwendet werden.

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;

Ergebnis¶

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;

Ergebnis¶

 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