Datentypzuordnungen in BigQuery

Auf dieser Seite wird beschrieben, wie Datastream Datentypen aus verschiedenen Quelldatenbanken den entsprechenden BigQuery-Datentypen zuordnet. Hier erfahren Sie, wie verschiedene Datentypen bei der Migration von Daten zu BigQuery konvertiert werden, wie BigQuery binäre JSON-Dokumente (BSON) von MongoDB darstellt und wie Sie PostgreSQL-Arraydaten als BigQuery-Datentyp ARRAY abfragen.

Datentypen zuordnen

In der folgenden Tabelle sind die Datentypkonvertierungen von unterstützten Quelldatenbanken in das BigQuery-Ziel aufgeführt.

Quelldatenbank Quelldatentyp BigQuery-Datentyp
MySQL BIGINT(size) INT64
MySQL BIGINT (unsigned) DECIMAL
MySQL BINARY(size) STRING (hex encoded)
MySQL BIT(size) INT64
MySQL BLOB(size) STRING (hex encoded)
MySQL BOOL INT64
MySQL CHAR(size) STRING
MySQL DATE DATE
MySQL DATETIME(fsp) DATETIME
MySQL DECIMAL(precision, scale) Wenn der Genauigkeitswert ≤ 38 und der Skalierungswert ≤ 9 ist, dann NUMERIC. Andernfalls BIGNUMERIC.
MySQL DOUBLE(size, d) FLOAT64
MySQL ENUM(val1, val2, val3, ...) STRING
MySQL FLOAT(precision) FLOAT64
MySQL FLOAT(size, d) FLOAT64
MySQL INTEGER(size) INT64
MySQL INTEGER (unsigned) INT64
MySQL

JSON

 JSON
MySQL LONGBLOB STRING (hex encoded)
MySQL LONGTEXT STRING
MySQL MEDIUMBLOB STRING (hex encoded)
MySQL MEDIUMINT(size) INT64
MySQL MEDIUMTEXT STRING
MySQL SET(val1, val2, val3, ...) STRING
MySQL SMALLINT(size) INT64
MySQL TEXT(size) STRING
MySQL TIME(fsp) INTERVAL
MySQL TIMESTAMP(fsp) TIMESTAMP
MySQL TINYBLOB STRING (hex encoded)
MySQL TINYINT(size) INT64
MySQL TINYTEXT STRING
MySQL VARBINARY(size) STRING (hex encoded)
MySQL VARCHAR STRING
MySQL YEAR INT64
Oracle ANYDATA UNSUPPORTED
Oracle BFILE UNSUPPORTED
Oracle BINARY DOUBLE FLOAT64
Oracle BINARY FLOAT FLOAT64
Oracle BLOB BYTES
Oracle CHAR STRING
Oracle CLOB STRING
Oracle DATE DATETIME
Oracle DOUBLE PRECISION FLOAT64
Oracle FLOAT(p) FLOAT64
Oracle INTERVAL DAY TO SECOND UNSUPPORTED
Oracle INTERVAL YEAR TO MONTH UNSUPPORTED
Oracle LONG oder LONG RAW UNSUPPORTED
Oracle NCHAR STRING
Oracle NCLOB STRING
Oracle NUMBER STRING
Oracle NUMBER(precision=*) STRING
Oracle NUMBER(precision, scale<=0) Wenn die Genauigkeit ≤ 18 ist, dann INT64. Wenn 18 < Genauigkeit ≤ 78, dann parametrisierten Dezimaltypen zuordnen. Wenn die Precision ≥ 79 ist, ordnen Sie sie STRING zu.
Oracle NUMBER(precision, scale>0) Wenn 0 < Genauigkeit ≤ 78, dann ordnen Sie parametrisierten Dezimaltypen zu. Wenn die Precision ≥ 79 ist, ordnen Sie sie STRING zu.
Oracle NVARCHAR2 STRING
Oracle RAW STRING
Oracle ROWID STRING
Oracle SDO_GEOMETRY UNSUPPORTED
Oracle SMALLINT INT64
Oracle TIMESTAMP TIMESTAMP
Oracle TIMESTAMP WITH TIME ZONE TIMESTAMP
Oracle UDT (user-defined type) UNSUPPORTED
Oracle UROWID UNSUPPORTED
Oracle VARCHAR STRING
Oracle VARCHAR2 STRING
Oracle XMLTYPE UNSUPPORTED
PostgreSQL ARRAY JSON
PostgreSQL BIGINT INT64
PostgreSQL BIT BYTES
PostgreSQL BIT VARYING BYTES
PostgreSQL BOOLEAN BOOLEAN
PostgreSQL BOX UNSUPPORTED
PostgreSQL BYTEA BYTES
PostgreSQL CHARACTER STRING
PostgreSQL CHARACTER VARYING STRING
PostgreSQL CIDR STRING
PostgreSQL CIRCLE UNSUPPORTED
PostgreSQL DATE DATE
PostgreSQL DOUBLE PRECISION FLOAT64
PostgreSQL ENUM STRING
PostgreSQL INET STRING
PostgreSQL INTEGER INT64
PostgreSQL INTERVAL INTERVAL
PostgreSQL JSON JSON
PostgreSQL JSONB JSON
PostgreSQL LINE UNSUPPORTED
PostgreSQL LSEG UNSUPPORTED
PostgreSQL MACADDR STRING
PostgreSQL MONEY FLOAT64
PostgreSQL NUMERIC Wenn „precision“ = -1, dann STRING (BigQuery-NUMERIC-Typen erfordern eine feste Genauigkeit). Andernfalls BIGNUMERIC oder NUMERIC. Weitere Informationen finden Sie im Abschnitt Arbitrary precision numbers (Zahlen mit beliebiger Genauigkeit) in der PostgreSQL-Dokumentation.
PostgreSQL OID INT64
PostgreSQL PATH UNSUPPORTED
PostgreSQL POINT UNSUPPORTED
PostgreSQL POLYGON UNSUPPORTED
PostgreSQL REAL FLOAT64
PostgreSQL SMALLINT INT64
PostgreSQL SMALLSERIAL INT64
PostgreSQL SERIAL INT64
PostgreSQL TEXT STRING
PostgreSQL TIME TIME
PostgreSQL TIMESTAMP TIMESTAMP
PostgreSQL TIMESTAMP WITH TIME ZONE TIMESTAMP
PostgreSQL TIME WITH TIME ZONE TIME
PostgreSQL TSQUERY STRING
PostgreSQL TSVECTOR STRING
PostgreSQL TXID SNAPSHOT STRING
PostgreSQL UUID STRING
PostgreSQL XML STRING
SQL Server BIGINT INT64
SQL Server BINARY BYTES
SQL Server BIT BOOL
SQL Server CHAR STRING
SQL Server DATE DATE
SQL Server DATETIME2 DATETIME
SQL Server DATETIME DATETIME
SQL Server DATETIMEOFFSET TIMESTAMP
SQL Server DECIMAL Wenn der Skalierungswert ≤ 9 und der (precision - scale)-Wert ≤ 29 ist, dann NUMERIC. Andernfalls: BIGNUMERIC.
SQL Server FLOAT FLOAT64
SQL Server IMAGE BYTES
SQL Server INT INT64
SQL Server MONEY NUMERIC
SQL Server NCHAR STRING
SQL Server NTEXT STRING
SQL Server NUMERIC Wenn der Skalierungswert ≤ 9 und der (precision - scale)-Wert ≤ 29 ist, dann NUMERIC. Andernfalls: BIGNUMERIC.
SQL Server NVARCHAR STRING
SQL Server NVARCHAR(MAX) STRING
SQL Server REAL FLOAT64
SQL Server SMALLDATETIME DATETIME
SQL Server SMALLINT INT64
SQL Server SMALLMONEY NUMERIC
SQL Server TEXT STRING
SQL Server TIME TIME
SQL Server TIMESTAMP oder ROWVERSION BYTES
SQL Server TINYINT INT64
SQL Server UNIQUEIDENTIFIER STRING
SQL Server VARBINARY BYTES
SQL Server VARBINARY(MAX) BYTES
SQL Server VARCHAR STRING
SQL Server VARCHAR(MAX) STRING
SQL Server XML STRING
Salesforce BOOLEAN BOOLEAN
Salesforce BYTE BYTES
Salesforce DATE DATE
Salesforce DATETIME DATETIME
Salesforce DOUBLE BIGNUMERIC
Salesforce INT INT64
Salesforce STRING STRING
Salesforce TIME TIME
Salesforce ANYTYPE
(kann STRING, DATE, NUMBER oder BOOLEAN sein)		 STRING
Salesforce COMBOBOX STRING
Salesforce CURRENCY FLOAT64

Die maximal zulässige Länge beträgt 18 Ziffern.
Salesforce DATACATEGORYGROUPREFERENCE STRING
Salesforce EMAIL STRING
Salesforce ENCRYPTEDSTRING STRING
Salesforce ID STRING
Salesforce JUNCTIONIDLIST STRING
Salesforce MASTERRECORD STRING
Salesforce MULTIPICKLIST STRING
Salesforce PERCENT FLOAT64

Die maximal zulässige Länge beträgt 18 Ziffern.
Salesforce PHONE STRING
Salesforce PICKLIST STRING
Salesforce REFERENCE STRING
Salesforce TEXTAREA STRING

Die maximal zulässige Länge beträgt 255 Zeichen.
Salesforce URL STRING
Spanner (GoogleSQL) ARRAY JSON
Spanner (GoogleSQL) BOOL BOOLEAN
Spanner (GoogleSQL) BYTES BYTES
Spanner (GoogleSQL) DATE DATE
Spanner (GoogleSQL) FLOAT32 FLOAT64
Spanner (GoogleSQL) FLOAT64 FLOAT64
Spanner (GoogleSQL) INT64 INT64
Spanner (GoogleSQL) JSON JSON
Spanner (GoogleSQL) NUMERIC STRING
Spanner (GoogleSQL) STRING STRING
Spanner (GoogleSQL) TIMESTAMP TIMESTAMP WITH TIME ZONE
Spanner (GoogleSQL) UUID STRING
Spanner (GoogleSQL) PROTO UNSUPPORTED
Spanner (GoogleSQL) ENUM UNSUPPORTED
Spanner (PostgreSQL) ARRAY JSON
Spanner (PostgreSQL) BIGINT INT64
Spanner (PostgreSQL) BOOL BOOLEAN
Spanner (PostgreSQL) BYTEA BYTES
Spanner (PostgreSQL) DATE DATE
Spanner (PostgreSQL) DECIMAL STRING
Spanner (PostgreSQL) DOUBLE PRECISION FLOAT64
Spanner (PostgreSQL) FLOAT8 FLOAT64
Spanner (PostgreSQL) INT8 INT64
Spanner (PostgreSQL) JSONB JSON
Spanner (PostgreSQL) NUMERIC STRING
Spanner (PostgreSQL) TIMESTAMP WITH TIME ZONE TIMESTAMP WITH TIME ZONE
Spanner (PostgreSQL) TIMESTAMPZ TIMESTAMP WITH TIME ZONE
Spanner (PostgreSQL) UUID STRING
Spanner (PostgreSQL) VARCHAR STRING

MongoDB-Datentypen

Binäre JSON-Dokumente (BSON) von MongoDB werden in einem von zwei Modi in BigQuery geschrieben, je nachdem, was Sie beim Erstellen des Streams angeben (siehe Streams verwalten): kanonischer Modus (Standard) oder strikter Modus.

  • Kanonischer Modus (Standard): Das moderne, beschreibende Format, bei dem die Datenintegrität im Vordergrund steht. Damit wird sichergestellt, dass jeder BSON-Typ explizit gekennzeichnet ist, z. B. dass zwischen einer 32-Bit- und einer 64-Bit-Ganzzahl unterschieden wird, um einen Genauigkeitsverlust beim Datenaustausch zu verhindern. Der kanonische Modus ist möglicherweise etwas langsamer als der strikte Modus, unterstützt aber alle Datentypen. Weitere Informationen finden Sie unter MongoDB Extended JSON.
  • Strenger Modus: Ein Legacy-Format, das mit JSON-Parsern kompatibel sein soll. Es verwendet bestimmte Konventionen wie "$date", um Typen darzustellen, die in Standard-JSON nicht vorhanden sind. Bestimmte Datentypen wie Infinity, -Infinity und NaN werden nicht unterstützt. Weitere Informationen finden Sie unter MongoDB Extended JSON (v1).

In der folgenden Tabelle sehen Sie, wie Datentypen in BigQuery in beiden Modi dargestellt werden, sowie Beispielwerte:

BSON-Datentyp Beispielwert Kanonischer Modus Strenger Modus
DOUBLE 3.1415926535 {"$numberDouble":"3.1415926535"} 3.1415926535
Infinity Infinity {"$numberDouble":"Infinity"} Nicht unterstützt
-Infinity -Infinity {"$numberDouble":"-Infinity"} Nicht unterstützt
NaN NaN {"$numberDouble":"NaN"} Nicht unterstützt
STRING "Hello, MongoDB!" "Hello, MongoDB!" "Hello, MongoDB!"
ARRAY 
[
  "item1",
  123,
  true,
  { subItem: "object in array" }
]
["item1",{"$numberInt":"123"},true,{"subItem":"object in array"}] ["item1",123,true,{"subItem":"object in array"}]
BINARY DATA new BinData(0, "SGVsbG8gQmluYXJ5IERhdGE=") {"$binary":{"base64":"SGVsbG8gQmluYXJ5IERhdGE=","subType":"00"}} {"$binary":"SGVsbG8gQmluYXJ5IERhdGE=","$type":"00"}
BOOLEAN true true true
DATE 2024-12-25T10:30:00.000+00:00 {"$date":{"$numberLong":"1735122600000"}} {"$date": 1735122600000}
NULL null null null
REGEX /^mongo(db)?$/i {"$regularExpression":{"pattern":"^mongo(db)?$","options":"i"}} {"$options":"i","$regex":"^mongo(db)?$"}
JAVASCRIPT function() {return this.stringField.length;} {"$code":"function() {\n return this.stringField.length;\n }"} {"$code":"function() {\n return this.stringField.length;\n }"}
DECIMAL128 NumberDecimal("1234567890.1234567890") {"$numberDecimal":"1234567890.1234567890"} {"$numberDecimal":"1234567890.1234567890"}
OBJECTID ObjectId('673c5d8dbfe2e51808cc2c3d') {"$oid": "673c5d8dbfe2e51808cc2c3d"} {"$oid": "673c5d8dbfe2e51808cc2c3d"}
LONG 3567587327 {"$numberLong": "3567587327"} {"$numberLong": "3567587327"}
INT32 42 {"$numberInt": "42"} 42
INT64 1864712049423024127 {"$numberLong": "1864712049423024127"} {"$numberLong": "1864712049423024127"}
TIMESTAMP new Timestamp(1747888877, 1) {"$timestamp":{"t":1747888877,"i":1}} {"$timestamp":{"i":1,"t":1747888877}}

PostgreSQL-Array als BigQuery-Array-Datentyp abfragen

Wenn Sie ein PostgreSQL-Array als BigQuery-Datentyp ARRAY abfragen möchten, konvertieren Sie die JSON-Werte mit der BigQuery-Funktion JSON_VALUE_ARRAY in ein BigQuery-Array:

  SELECT
    ARRAY(
      SELECT CAST(element AS TYPE)
      FROM UNNEST(JSON_VALUE_ARRAY(BQ_COLUMN_NAME, '$')) AS element
    ) AS array_col

Ersetzen Sie Folgendes:

  • TYPE: Der BigQuery-Typ, der dem Elementtyp im PostgreSQL-Quellarray entspricht. Wenn der Quelltyp beispielsweise ein Array von BIGINT-Werten ist, ersetzen Sie TYPE durch INT64. Weitere Informationen zum Zuordnen der Datentypen finden Sie unter Datentypen zuordnen.
  • BQ_COLUMN_NAME: Der Name der relevanten Spalte in der BigQuery-Tabelle.

Es gibt zwei Ausnahmen bei der Umrechnung der Werte:

  • Führen Sie für Arrays mit BIT-, BIT_VARYING- oder BYTEA-Werten in der Quellspalte die folgende Abfrage aus:

    SELECT
  ARRAY(
    SELECT FROM_BASE64(element)
    FROM UNNEST(JSON_VALUE_ARRAY(BQ_COLUMN_NAME, '$')) AS element
  ) AS array_of_bytes

  • Verwenden Sie für Arrays mit JSON- oder JSONB-Werten in der Quellspalte die Funktion JSON_QUERY_ARRAY:

    SELECT
  ARRAY(
    SELECT element
    FROM UNNEST(JSON_QUERY_ARRAY(BQ_COLUMN_NAME, '$')) AS element
  ) AS array_of_jsons