Leitfaden zur Apache Hive-SQL-Übersetzung

In diesem Dokument werden die Gemeinsamkeiten und Unterschiede in der SQL-Syntax zwischen Apache Hive und BigQuery beschrieben, damit Sie die Migration planen können. Wenn Sie Ihre SQL-Scripts im Bulk migrieren möchten, verwenden Sie die Batch-SQL-Übersetzung. Verwenden Sie zum Übersetzen von Ad-hoc-Abfragen die interaktive SQL-Übersetzung.

In einigen Fällen können SQL-Elemente aus Hive und BigQuery nicht direkt zugeordnet werden. In den meisten Fällen bietet BigQuery jedoch ein alternatives Element für Hive, damit Sie dieselbe Funktionalität erreichen, wie in den Beispielen in diesem Dokument gezeigt.

Dieses Dokument richtet sich an Unternehmensarchitekten, Datenbankadministratoren, Anwendungsentwickler und IT-Sicherheitsexperten. Es wird davon ausgegangen, dass Sie mit Hive vertraut sind.

Datentypen

Apache Hive und BigQuery haben unterschiedliche Datentypsysteme. In den meisten Fällen können Sie Datentypen aus Hive den BigQuery-Datentypen zuordnen. Ausnahmen sind hier z. B. MAP und UNION. Hive unterstützt eine weniger explizite Typumwandlung als BigQuery. Daher fügt der Batch-SQL-Übersetzer viele explizite Umwandlungen ein.

Hive	BigQuery
TINYINT	INT64
SMALLINT	INT64
INT	INT64
BIGINT	INT64
DECIMAL	NUMERIC
FLOAT	FLOAT64
DOUBLE	FLOAT64
BOOLEAN	BOOL
STRING	STRING
VARCHAR	STRING
CHAR	STRING
BINARY	BYTES
DATE	DATE
-	DATETIME
–	TIME
TIMESTAMP	DATETIME/TIMESTAMP
INTERVAL	-
ARRAY	ARRAY
STRUCT	STRUCT
MAPS	STRUCT mit Schlüsselwerten (Feld REPEAT)
UNION	STRUCT mit unterschiedlichen Typen
-	GEOGRAPHY
-	JSON

Abfragesyntax

In diesem Abschnitt werden Unterschiede in der Abfragesyntax zwischen Hive und BigQuery behandelt.

SELECT-Anweisung

Die meisten Hive-SELECT-Anweisungen sind mit BigQuery kompatibel. Die folgende Tabelle enthält eine Liste kleinerer Unterschiede:

Fall-	Hive	BigQuery
Unterabfrage	SELECT * FROM ( SELECT 10 as col1, "test" as col2, "test" as col3 ) tmp_table;	SELECT * FROM ( SELECT 10 as col1, "test" as col2, "test" as col3 );
Spaltenfilterung	SET hive.support.quoted.identifiers=none; SELECT `(col2|col3)?+.+` FROM ( SELECT 10 as col1, "test" as col2, "test" as col3 ) tmp_table;	SELECT * EXCEPT(col2,col3) FROM ( SELECT 10 as col1, "test" as col2, "test" as col3 );
Maximieren eines Arrays	SELECT tmp_table.pageid, adid FROM ( SELECT 'test_value' pageid, Array(1,2,3) ad_id) tmp_table LATERAL VIEW explode(tmp_table.ad_id) adTable AS adid;	SELECT tmp_table.pageid, ad_id FROM ( SELECT 'test_value' pageid, [1,2,3] ad_id) tmp_table, UNNEST(tmp_table.ad_id) ad_id;

FROM-Klausel

In der FROM-Klausel einer Abfrage werden die Tabellenreferenzen aufgelistet, aus denen Daten ausgewählt werden. In Hive können Tabellenreferenzen Tabellen, Ansichten und Unterabfragen sein. BigQuery unterstützt ebenfalls alle diese Tabellenreferenzen.

Sie können in der FROM-Klausel auf BigQuery-Tabellen verweisen, indem Sie Folgendes verwenden:

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

BigQuery unterstützt auch zusätzliche Tabellenreferenzen:

• Frühere Versionen der Tabellendefinition und der Zeilen mit FOR SYSTEM_TIME AS OF
• Feldpfade und jeden Pfad, der in ein Feld innerhalb eines Datentyps aufgelöst wird (z. B. STRUCT)
• Vereinfachte Arrays

Vergleichsoperator

Die folgende Tabelle enthält Details zum Konvertieren von Operatoren von Hive in BigQuery:

Funktion oder Operator	Hive	BigQuery
- Unäres Minus * Multiplikation / Division + Addition - Subtraktion	Alle Zahlentypen	Alle Zahlentypen Verwenden Sie SAFE_DIVIDE oder IEEE_DIVIDE, um Fehler während der Division zu vermeiden.
~ Bitweises NOT | Bitweises OR & Bitweises AND ^ Bitweises XOR	Boolescher Datentyp	Boolescher Datentyp
Linksverschiebung	shiftleft(TINYINT|SMALLINT|INT a, INT b) shiftleft(BIGINT a, INT b)	<< Ganzzahl oder Byte A << B, wobei B denselben Typ wie A haben muss
Rechtsverschiebung	shiftright(TINYINT|SMALLINT|INT a, INT b) shiftright(BIGINT a, INT b)	>> Ganzzahl oder Byte A >> B, wobei B denselben Typ wie A haben muss
Modulo (Rest)	X % Y Alle Zahlentypen	MOD(X, Y)
Ganzzahldivision	A DIV B und A/B für detaillierte Genauigkeit	Alle Zahlentypen Hinweis: Verwenden Sie SAFE_DIVIDE oder IEEE_DIVIDE, um Fehler während der Division zu vermeiden.
Unäre Negation	!, NOT	NOT
Typen, die Gleichheitsvergleiche unterstützen	Alle primitiven Typen	Alle vergleichbaren Typen und STRUCT
	a <=> b	Nicht unterstützt. Übersetzen Sie in Folgendes: (a = b AND b IS NOT NULL OR a IS NULL)
	a <> b	Nicht unterstützt. Übersetzen Sie in Folgendes: NOT (a = b AND b IS NOT NULL OR a IS NULL)
Relationale Operatoren ( =, ==, !=, <, >, >= )	Alle primitiven Typen	Alle vergleichbaren Typen
Stringvergleich	RLIKE, REGEXP	Integrierte REGEXP_CONTAINS Funktion. Verwendet die Regex-Syntax für Stringfunktionen von BigQuery für die Muster regulärer Ausdrücke.
[NOT] LIKE, [NOT] BETWEEN, IS [NOT] NULL	A [NOT] BETWEEN B AND C, A IS [NOT] (TRUE|FALSE), A [NOT] LIKE B	Identisch mit Hive. Darüber hinaus unterstützt BigQuery auch den Operator IN.

JOIN-Bedingungen

Sowohl Hive als auch BigQuery unterstützen die folgenden Join-Typen:

• [INNER] JOIN

• LEFT [OUTER] JOIN

• RIGHT [OUTER] JOIN

• FULL [OUTER] JOIN

• CROSS JOIN und den entsprechenden impliziten durch Komma getrennten Cross Join

Weitere Informationen finden Sie unter Join-Vorgang und Hive-Joins.

Typkonvertierung und -umwandlung

Die folgende Tabelle enthält Details zur Konvertierung von Funktionen aus Hive in BigQuery:

Funktion oder Operator	Hive	BigQuery
Typumwandlung	Wenn eine Umwandlung fehlschlägt, wird `NULL` zurückgegeben.	Gleiche Syntax wie Hive. Weitere Informationen zu BigQuery-Typkonvertierungsregeln finden Sie unter Konvertierungsregeln. Wenn die Umwandlung fehlschlägt, wird ein Fehler angezeigt. Verwenden Sie stattdessen SAFE_CAST, um dasselbe Verhalten wie Hive zu erreichen.
SAFE-Funktionsaufrufe		Wenn Sie Funktionsaufrufen SAFE voranstellen, gibt die Funktion NULL zurück, statt einen Fehler zu melden. Beispiel: SAFE.SUBSTR('foo', 0, -2) AS safe_output; gibt NULL zurück. Hinweis: Verwenden Sie für eine sichere Umwandlung ohne Fehler SAFE_CAST.

Implizite Konvertierungstypen

Bei der Migration zu BigQuery müssen Sie die meisten impliziten Hive-Konvertierungen in explizite BigQuery-Konvertierungen konvertieren, mit Ausnahme der folgenden Datentypen, die BigQuery implizit konvertiert.

Von BigQuery-Typ	Zu BigQuery-Typ
INT64	FLOAT64, NUMERIC, BIGNUMERIC
BIGNUMERIC	FLOAT64
NUMERIC	BIGNUMERIC, FLOAT64

BigQuery führt auch implizite Konvertierungen für die folgenden Literale durch:

Von BigQuery-Typ	Zu BigQuery-Typ
STRING-Literal (z. B. "2008-12-25")	DATE
STRING-Literal (z. B. "2008-12-25 15:30:00")	TIMESTAMP
STRING-Literal (z. B. "2008-12-25T07:30:00")	DATETIME
STRING-Literal (z. B. "15:30:00")	TIME

Explizite Konvertierungstypen

Wenn Sie Hive-Datentypen konvertieren möchten, die BigQuery nicht implizit konvertiert, verwenden Sie die BigQuery-CAST(expression AS type)-Funktion oder entweder die DATE- oder die TIMESTAMP- Konvertierungsfunktion.

Funktionen

In diesem Abschnitt werden gängige Funktionen in Hive und BigQuery behandelt.

Aggregatfunktionen

Die folgende Tabelle zeigt Zuordnungen zwischen gängigen Hive-Aggregationsfunktionen, statistischen Aggregationsfunktionen und ungefähren Aggregationsfunktionen mit ihren BigQuery-Entsprechungen:

Hive	BigQuery
count(DISTINCT expr[, expr...])	count(DISTINCT expr[, expr...])
percentile_approx(DOUBLE col, array(p1 [, p2]...) [, B]) WITHIN GROUP (ORDER BY expression)	APPROX_QUANTILES(expression, 100)[OFFSET(CAST(TRUNC(percentile * 100) as INT64))] BigQuery unterstützt die übrigen von Hive definierten Argumente nicht.
AVG	AVG
X | Y	BIT_OR / X | Y
X ^ Y	BIT_XOR / X ^ Y
X & Y	BIT_AND / X & Y
COUNT	COUNT
COLLECT_SET(col), \ COLLECT_LIST(col)	ARRAY_AGG(col)
COUNT	COUNT
MAX	MAX
MIN	MIN
REGR_AVGX	AVG( IF(dep_var_expr is NULL OR ind_var_expr is NULL, NULL, ind_var_expr) )
REGR_AVGY	AVG( IF(dep_var_expr is NULL OR ind_var_expr is NULL, NULL, dep_var_expr) )
REGR_COUNT	SUM( IF(dep_var_expr is NULL OR ind_var_expr is NULL, NULL, 1) )
REGR_INTERCEPT	AVG(dep_var_expr) - AVG(ind_var_expr) * (COVAR_SAMP(ind_var_expr,dep_var_expr) / VARIANCE(ind_var_expr) )
REGR_R2	(COUNT(dep_var_expr) * SUM(ind_var_expr * dep_var_expr) - SUM(dep_var_expr) * SUM(ind_var_expr)) / SQRT( (COUNT(ind_var_expr) * SUM(POWER(ind_var_expr, 2)) * POWER(SUM(ind_var_expr),2)) * (COUNT(dep_var_expr) * SUM(POWER(dep_var_expr, 2)) * POWER(SUM(dep_var_expr), 2)))
REGR_SLOPE	COVAR_SAMP(ind_var_expr, dep_var_expr) / VARIANCE(ind_var_expr)
REGR_SXX	SUM(POWER(ind_var_expr, 2)) - COUNT(ind_var_expr) * POWER(AVG(ind_var_expr),2)
REGR_SXY	SUM(ind_var_expr*dep_var_expr) - COUNT(ind_var_expr) * AVG(ind) * AVG(dep_var_expr)
REGR_SYY	SUM(POWER(dep_var_expr, 2)) - COUNT(dep_var_expr) * POWER(AVG(dep_var_expr),2)
ROLLUP	ROLLUP
STDDEV_POP	STDDEV_POP
STDDEV_SAMP	STDDEV_SAMP, STDDEV
SUM	SUM
VAR_POP	VAR_POP
VAR_SAMP	VAR_SAMP, VARIANCE
CONCAT_WS	STRING_AGG

Analysefunktionen

Die folgende Tabelle zeigt Zuordnungen zwischen gängigen Hive-Analysefunktionen und den BigQuery-Entsprechungen:

Hive	BigQuery
AVG	AVG
COUNT	COUNT
COVAR_POP	COVAR_POP
COVAR_SAMP	COVAR_SAMP
CUME_DIST	CUME_DIST
DENSE_RANK	DENSE_RANK
FIRST_VALUE	FIRST_VALUE
LAST_VALUE	LAST_VALUE
LAG	LAG
LEAD	LEAD
COLLECT_LIST, \ COLLECT_SET	ARRAY_AGG ARRAY_CONCAT_AGG
MAX	MAX
MIN	MIN
NTILE	NTILE(constant_integer_expression)
PERCENT_RANK	PERCENT_RANK
RANK ()	RANK
ROW_NUMBER	ROW_NUMBER
STDDEV_POP	STDDEV_POP
STDDEV_SAMP	STDDEV_SAMP, STDDEV
SUM	SUM
VAR_POP	VAR_POP
VAR_SAMP	VAR_SAMP, VARIANCE
VARIANCE	VARIANCE ()
WIDTH_BUCKET	Es kann eine benutzerdefinierte Funktion (UDF) verwendet werden.

Funktionen für Datum und Uhrzeit

Die folgende Tabelle zeigt Zuordnungen zwischen gängigen Hive-Datums- und -Uhrzeitfunktionen und ihren BigQuery-Entsprechungen:

DATE_ADD	DATE_ADD(date_expression, INTERVAL int64_expression date_part)
DATE_SUB	DATE_SUB(date_expression, INTERVAL int64_expression date_part)
CURRENT_DATE	CURRENT_DATE
CURRENT_TIME	CURRENT_TIME
CURRENT_TIMESTAMP	CURRENT_DATETIME wird empfohlen, da dieser Wert zeitzonenunabhängig und synonym mit CURRENT_TIMESTAMP \ CURRENT_TIMESTAMP in Hive ist.
EXTRACT(field FROM source)	EXTRACT(part FROM datetime_expression)
LAST_DAY	DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 MONTH ), MONTH ), INTERVAL 1 DAY)
MONTHS_BETWEEN	DATE_DIFF(date_expression, date_expression, MONTH)
NEXT_DAY	DATE_ADD( DATE_TRUNC( date_expression, WEEK(day_value) ), INTERVAL 1 WEEK )
TO_DATE	PARSE_DATE
FROM_UNIXTIME	UNIX_SECONDS
FROM_UNIXTIMESTAMP	FORMAT_TIMESTAMP
YEAR \ QUARTER \ MONTH \ HOUR \ MINUTE \ SECOND \ WEEKOFYEAR	EXTRACT
DATEDIFF	DATE_DIFF

BigQuery bietet die folgenden zusätzlichen Datums- und Uhrzeitfunktionen:

CURRENT_DATETIME DATE_FROM_UNIX_DATE DATE_TRUNC DATETIME DATETIME_TRUNC FORMAT_DATE FORMAT_DATETIME FORMAT_TIME

FORMAT_TIMESTAMP PARSE_DATETIME PARSE_TIME STRING TIME TIME_ADD TIME_DIFF TIME_SUB TIME_TRUNC TIMESTAMP TIMESTAMP_ADD

TIMESTAMP_DIFF TIMESTAMP_MICROS TIMESTAMP_MILLIS TIMESTAMP_SECONDS TIMESTAMP_SUB TIMESTAMP_TRUNC UNIX_DATE UNIX_MICROS UNIX_MILLIS UNIX_SECONDS

Stringfunktionen

Die folgende Tabelle zeigt Zuordnungen zwischen Hive-Stringfunktionen und ihren BigQuery-Entsprechungen:

Hive	BigQuery
ASCII	TO_CODE_POINTS(string_expr)[OFFSET(0)]
HEX	TO_HEX
LENGTH	CHAR_LENGTH
LENGTH	CHARACTER_LENGTH
CHR	CODE_POINTS_TO_STRING
CONCAT	CONCAT
LOWER	LOWER
LPAD	LPAD
LTRIM	LTRIM
REGEXP_EXTRACT	REGEXP_EXTRACT
REGEXP_REPLACE	REGEXP_REPLACE
REPLACE	REPLACE
REVERSE	REVERSE
RPAD	RPAD
RTRIM	RTRIM
SOUNDEX	SOUNDEX
SPLIT	SPLIT(instring, delimiter)[ORDINAL(tokennum)]
SUBSTR, \ SUBSTRING	SUBSTR
TRANSLATE	TRANSLATE
LTRIM	LTRIM
RTRIM	RTRIM
TRIM	TRIM
UPPER	UPPER

BigQuery bietet die folgenden zusätzlichen Stringfunktionen:

BYTE_LENGTH CODE_POINTS_TO_BYTES ENDS_WITH FROM_BASE32 FROM_BASE64 FROM_HEX NORMALIZE NORMALIZE_AND_CASEFOLD

REPEAT SAFE_CONVERT_BYTES_TO_STRING SPLIT STARTS_WITH STRPOS TO_BASE32 TO_BASE64 TO_CODE_POINTS

Mathematische Funktionen:

Die folgende Tabelle zeigt Zuordnungen zwischen den mathematischen Hive-Funktionen und ihren BigQuery-Entsprechungen:

Hive	BigQuery
ABS	ABS
ACOS	ACOS
ASIN	ASIN
ATAN	ATAN
CEIL	CEIL
CEILING	CEILING
COS	COS
FLOOR	FLOOR
GREATEST	GREATEST
LEAST	LEAST
LN	LN
LNNVL	Wird mit ISNULL verwendet
LOG	LOG
MOD (% operator)	MOD
POWER	POWER, POW
RAND	RAND
ROUND	ROUND
SIGN	SIGN
SIN	SIN
SQRT	SQRT
HASH	FARM_FINGERPRINT, MD5, SHA1, SHA256, SHA512
STDDEV_POP	STDDEV_POP
STDDEV_SAMP	STDDEV_SAMP
TAN	TAN
TRUNC	TRUNC
NVL	IFNULL(expr, 0), COALESCE(exp, 0)

BigQuery bietet die folgenden zusätzlichen mathematischen Funktionen:

• DIV
• IEEE_DIVIDE
• IS_INF
• IS_NAN
• LOG10
• SAFE_DIVIDE

Logische und bedingte Funktionen

Die folgende Tabelle zeigt Zuordnungen zwischen logischen und bedingten Hive-Funktionen und ihren BigQuery-Entsprechungen:

Hive	BigQuery
CASE	CASE
COALESCE	COALESCE
NVL	IFNULL(expr, 0), COALESCE(exp, 0)
NULLIF	NULLIF
IF	IF(expr, true_result, else_result)
ISNULL	IS NULL
ISNOTNULL	IS NOT NULL
NULLIF	NULLIF

UDFs und UDAFs

BigQuery unterstützt UDFs, aber keine benutzerdefinierten Aggregationsfunktionen (UDAFs).

DML-Syntax

In diesem Abschnitt werden Unterschiede in der Syntax der Datenbearbeitungssprache (Data Manipulation Language, DML) zwischen Hive und BigQuery behandelt.

INSERT-Anweisung

Die meisten Hive-INSERT-Anweisungen sind mit BigQuery kompatibel. Die folgende Tabelle zeigt Ausnahmen:

Hive	BigQuery
INSERT INTO TABLE tablename [PARTITION (partcol1[=val1], partcol2[=val2] ...)] VALUES values_row [, values_row ...]	INSERT INTO table (...) VALUES (...); Hinweis: In BigQuery funktioniert das Weglassen von Spaltennamen in der Anweisung INSERT nur, wenn Werte für alle Spalten in der Zieltabelle auf der Grundlage ihrer ordinalen Positionen in aufsteigender Reihenfolge enthalten sind.
INSERT OVERWRITE [LOCAL] DIRECTORY directory1 [ROW FORMAT row_format] [STORED AS file_format] (Note: Only available starting with Hive 0.11.0) SELECT ... FROM ...	BigQuery unterstützt keine Einfügungs-/Überschreibungsvorgänge. Diese Hive-Syntax kann zu den Anweisungen TRUNCATE und INSERT migriert werden.

BigQuery legt DML-Kontingente fest, die die Anzahl der DML-Anweisungen begrenzen, die Sie täglich ausführen können. Ziehen Sie die folgenden Ansätze in Betracht, um Ihr Kontingent optimal zu nutzen:

• Kombinieren Sie mehrere Zeilen in einer einzigen INSERT-Anweisung anstelle einer Zeile für jeden INSERT-Vorgang.

• Kombinieren Sie mehrere DML-Anweisungen (einschließlich INSERT) mithilfe einer MERGE-Anweisung.

• Mit CREATE TABLE ... AS SELECT können Sie neue Tabellen erstellen und mit Daten füllen.

UPDATE-Anweisung

Die meisten Hive-UPDATE-Anweisungen sind mit BigQuery kompatibel. Die folgende Tabelle zeigt Ausnahmen:

Hive	BigQuery
UPDATE tablename SET column = value [, column = value ...] [WHERE expression]	UPDATE table SET column = expression [,...] [FROM ...] WHERE TRUE Hinweis: Alle UPDATE-Anweisungen in BigQuery erfordern das Schlüsselwort WHERE, gefolgt von einer Bedingung.

DELETE- und TRUNCATE-Anweisungen

Mit der Anweisung DELETE oder TRUNCATE können Sie Zeilen aus einer Tabelle entfernen, ohne dass sich dies auf das Tabellenschema oder die Indexe auswirkt.

In BigQuery muss die DELETE-Anweisung eine WHERE-Klausel enthalten. Weitere Informationen zu DELETE in BigQuery finden Sie unter DELETE-Beispiele.

Hive	BigQuery
DELETE FROM tablename [WHERE expression]	DELETE FROM table_name WHERE TRUE BigQuery-DELETE-Anweisungen erfordern eine WHERE -Klausel.
TRUNCATE [TABLE] table_name [PARTITION partition_spec];	TRUNCATE TABLE [[project_name.]dataset_name.]table_name

MERGE-Anweisung

Die MERGE-Anweisung kann die Vorgänge INSERT, UPDATE und DELETE in einer einzigen Upsert-Anweisung kombinieren und die Vorgänge ausführen. Der MERGE-Vorgang darf mit maximal einer Quellzeile für jede Zielzeile übereinstimmen.

Hive	BigQuery
MERGE INTO AS T USING AS S ON WHEN MATCHED [AND ] THEN UPDATE SET WHEN MATCHED [AND ] THEN DELETE WHEN NOT MATCHED [AND ] THEN INSERT VALUES	MERGE target USING source ON target.key = source.key WHEN MATCHED AND source.filter = 'filter_exp' THEN UPDATE SET target.col1 = source.col1, target.col2 = source.col2, ... Hinweis: Sie müssen alle Spalten auflisten, die aktualisiert werden müssen.

ALTER-Anweisung

Die folgende Tabelle enthält Details zur Konvertierung von CREATE VIEW-Anweisungen aus Hive in BigQuery:

Funktion	Hive	BigQuery
Rename table	ALTER TABLE table_name RENAME TO new_table_name;	Nicht unterstützt. Das Problem lässt sich umgehen, wenn Sie einen Kopierjob mit dem gewünschten Namen als Zieltabelle verwenden und dann die alte Tabelle löschen. bq copy project.dataset.old_table project.dataset.new_table bq rm --table project.dataset.old_table
Table properties	ALTER TABLE table_name SET TBLPROPERTIES table_properties; table_properties: : (property_name = property_value, property_name = property_value, ... ) Table Comment: ALTER TABLE table_name SET TBLPROPERTIES ('comment' = new_comment);	{ALTER TABLE | ALTER TABLE IF EXISTS} table_name SET OPTIONS(table_set_options_list)
SerDe properties (Serialize and deserialize)	ALTER TABLE table_name [PARTITION partition_spec] SET SERDE serde_class_name [WITH SERDEPROPERTIES serde_properties]; ALTER TABLE table_name [PARTITION partition_spec] SET SERDEPROPERTIES serde_properties; serde_properties: : (property_name = property_value, property_name = property_value, ... )	Die Serialisierung und Deserialisierung wird vom BigQuery-Dienst verwaltet und kann nicht vom Nutzer konfiguriert werden. Informationen zum Lesen von Daten aus CSV-, JSON-, AVRO-, PARQUET- oder ORC-Dateien in BigQuery finden Sie unter Externe Cloud Storage-Tabellen erstellen. Unterstützt die Exportformate CSV, JSON, AVRO und PARQUET. Weitere Informationen finden Sie unter Exportformate und Komprimierungstypen.
Table storage properties	ALTER TABLE table_name CLUSTERED BY (col_name, col_name, ...) [SORTED BY (col_name, ...)] INTO num_buckets BUCKETS;	Nicht unterstützt für ALTER-Anweisungen.
Skewed table	Skewed: ALTER TABLE table_name SKEWED BY (col_name1, col_name2, ...) ON ([(col_name1_value, col_name2_value, ...) [, (col_name1_value, col_name2_value), ...] [STORED AS DIRECTORIES]; Not Skewed: ALTER TABLE table_name NOT SKEWED; Not Stored as Directories: ALTER TABLE table_name NOT STORED AS DIRECTORIES; Skewed Location: ALTER TABLE table_name SET SKEWED LOCATION (col_name1="location1" [, col_name2="location2", ...] );	Die Abstimmung des Speicherplatzes für Leistungsabfragen wird vom BigQuery-Dienst verwaltet und kann nicht konfiguriert werden.
Table constraints	ALTER TABLE table_name ADD CONSTRAINT constraint_name PRIMARY KEY (column, ...) DISABLE NOVALIDATE; ALTER TABLE table_name ADD CONSTRAINT constraint_name FOREIGN KEY (column, ...) REFERENCES table_name(column, ...) DISABLE NOVALIDATE RELY; ALTER TABLE table_name DROP CONSTRAINT constraint_name;	ALTER TABLE [[project_name.]dataset_name.]table_name ADD [CONSTRAINT [IF NOT EXISTS] [constraint_name]] constraint NOT ENFORCED; ALTER TABLE [[project_name.]dataset_name.]table_name ADD PRIMARY KEY(column_list) NOT ENFORCED; Weitere Informationen finden Sie unter ALTER TABLE ADD PRIMARY KEY-Anweisung.
Add partition	ALTER TABLE table_name ADD [IF NOT EXISTS] PARTITION partition_spec [LOCATION 'location'][, PARTITION partition_spec [LOCATION 'location'], ...]; partition_spec: : (partition_column = partition_col_value, partition_column = partition_col_value, ...)	Nicht unterstützt. Bei Bedarf werden zusätzliche Partitionen hinzugefügt, wenn Daten mit neuen Werten in die Partitionsspalten geladen werden. Weitere Informationen finden Sie unter Partitionierte Tabellen verwalten.
Rename partition	ALTER TABLE table_name PARTITION partition_spec RENAME TO PARTITION partition_spec;	Nicht unterstützt.
Exchange partition	-- Move partition from table_name_1 to table_name_2 ALTER TABLE table_name_2 EXCHANGE PARTITION (partition_spec) WITH TABLE table_name_1; -- multiple partitions ALTER TABLE table_name_2 EXCHANGE PARTITION (partition_spec, partition_spec2, ...) WITH TABLE table_name_1;	Nicht unterstützt.
Recover partition	MSCK [REPAIR] TABLE table_name [ADD/DROP/SYNC PARTITIONS];	Nicht unterstützt.
Drop partition	ALTER TABLE table_name DROP [IF EXISTS] PARTITION partition_spec[, PARTITION partition_spec, ...] [IGNORE PROTECTION] [PURGE];	Unterstützt mit den folgenden Methoden: bq rm 'mydataset.table_name$partition_id' DELETE from table_name$partition_id WHERE 1=1 Weitere Informationen finden Sie unter Partition löschen.
(Un)Archive partition	ALTER TABLE table_name ARCHIVE PARTITION partition_spec; ALTER TABLE table_name UNARCHIVE PARTITION partition_spec;	Nicht unterstützt.
Table and partition file format	ALTER TABLE table_name [PARTITION partition_spec] SET FILEFORMAT file_format;	Nicht unterstützt.
Table and partition location	ALTER TABLE table_name [PARTITION partition_spec] SET LOCATION "new location";	Nicht unterstützt.
Table and partition touch	ALTER TABLE table_name TOUCH [PARTITION partition_spec];	Nicht unterstützt.
Table and partition protection	ALTER TABLE table_name [PARTITION partition_spec] ENABLE|DISABLE NO_DROP [CASCADE]; ALTER TABLE table_name [PARTITION partition_spec] ENABLE|DISABLE OFFLINE;	Nicht unterstützt.
Table and partition compact	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] COMPACT 'compaction_type'[AND WAIT] [WITH OVERWRITE TBLPROPERTIES ("property"="value" [, ...])];	Nicht unterstützt.
Table and artition concatenate	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] CONCATENATE;	Nicht unterstützt.
Table and partition columns	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] UPDATE COLUMNS;	Nicht unterstützt für ALTER TABLE-Anweisungen.
Column name, type, position, and comment	ALTER TABLE table_name [PARTITION partition_spec] CHANGE [COLUMN] col_old_name col_new_name column_type [COMMENT col_comment] [FIRST|AFTER column_name] [CASCADE|RESTRICT];	Nicht unterstützt.

DDL-Syntax

In diesem Abschnitt werden Unterschiede in der DDL-Syntax (Data Definition Language, Datendefinitionssprache) zwischen Hive und BigQuery behandelt.

CREATE TABLE- und DROP TABLE-Anweisungen

Die folgende Tabelle enthält Details zur Konvertierung von CREATE TABLE-Anweisungen aus Hive in BigQuery:

Typ	Hive	BigQuery
Verwaltete Tabellen	create table table_name ( id int, dtDontQuery string, name string )	CREATE TABLE `myproject`.mydataset.table_name ( id INT64, dtDontQuery STRING, name STRING )
Partitionierte Tabellen	create table table_name ( id int, dt string, name string ) partitioned by (date string)	CREATE TABLE `myproject`.mydataset.table_name ( id INT64, dt DATE, name STRING ) PARTITION BY dt OPTIONS( partition_expiration_days=3, description="a table partitioned by date_col" )
Create table as select (CTAS)	CREATE TABLE new_key_value_store ROW FORMAT SERDE "org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe" STORED AS RCFile AS SELECT (key % 1024) new_key, concat(key, value) key_value_pair, dt FROM key_value_store SORT BY new_key, key_value_pair;	CREATE TABLE `myproject`.mydataset.new_key_value_store Entfernen Sie bei der Partitionierung nach Datum die Kommentarzeichen bei Folgendem: PARTITION BY dt OPTIONS( description="Table Description", Entfernen Sie bei der Partitionierung nach Datum die Kommentarzeichen bei Folgendem. Es wird empfohlen, require_partition zu verwenden, wenn die Tabelle partitioniert ist. require_partition_filter=TRUE ) AS SELECT (key % 1024) new_key, concat(key, value) key_value_pair, dt FROM key_value_store SORT BY new_key, key_value_pair'
Create Table Like: Mit der LIKE-Form von CREATE TABLE können Sie eine vorhandene Tabellendefinition genau kopieren.	CREATE TABLE empty_key_value_store LIKE key_value_store [TBLPROPERTIES (property_name=property_value, ...)];	Nicht unterstützt.
Sortierte Bucket-Tabellen (in BigQuery-Terminologie geclustert)	CREATE TABLE page_view( viewTime INT, userid BIGINT, page_url STRING, referrer_url STRING, ip STRING COMMENT 'IP Address of the User' ) COMMENT 'This is the page view table' PARTITIONED BY(dt STRING, country STRING) CLUSTERED BY(userid) SORTED BY(viewTime) INTO 32 BUCKETS ROW FORMAT DELIMITED FIELDS TERMINATED BY '\001' COLLECTION ITEMS TERMINATED BY '\002' MAP KEYS TERMINATED BY '\003' STORED AS SEQUENCEFILE;	CREATE TABLE `myproject` mydataset.page_view ( viewTime INT, dt DATE, userId BIGINT, page_url STRING, referrer_url STRING, ip STRING OPTIONS (description="IP Address of the User") ) PARTITION BY dt CLUSTER BY userId OPTIONS ( partition_expiration_days=3, description="This is the page view table", require_partition_filter=TRUE )' Weitere Informationen finden Sie unter Geclusterte Tabellen erstellen und verwenden.
Verzerrte Tabellen (Tabellen, in denen eine oder mehrere Spalten verzerrte Werte haben)	CREATE TABLE list_bucket_multiple (col1 STRING, col2 int, col3 STRING) SKEWED BY (col1, col2) ON (('s1',1), ('s3',3), ('s13',13), ('s78',78)) [STORED AS DIRECTORIES];	Nicht unterstützt.
Temporäre Tabellen	CREATE TEMPORARY TABLE list_bucket_multiple ( col1 STRING, col2 int, col3 STRING);	Dies lässt sich mithilfe der Ablaufzeit so erreichen: CREATE TABLE mydataset.newtable ( col1 STRING OPTIONS(description="An optional INTEGER field"), col2 INT64, col3 STRING ) PARTITION BY DATE(_PARTITIONTIME) OPTIONS( expiration_timestamp=TIMESTAMP "2020-01-01 00:00:00 UTC", partition_expiration_days=1, description="a table that expires in 2020, with each partition living for 24 hours", labels=[("org_unit", "development")] )
Transaktionale Tabellen	CREATE TRANSACTIONAL TABLE transactional_table_test(key string, value string) PARTITIONED BY(ds string) STORED AS ORC;	Alle Tabellenänderungen in BigQuery sind ACID-konform (Atomarität, Konsistenz, Isolation, Langlebigkeit).
Tabelle löschen	DROP TABLE [IF EXISTS] table_name [PURGE];	{DROP TABLE | DROP TABLE IF EXISTS} table_name
Tabelle kürzen	TRUNCATE TABLE table_name [PARTITION partition_spec]; partition_spec: : (partition_column = partition_col_value, partition_column = partition_col_value, ...)	Nicht unterstützt. Folgende Problemumgehungen sind verfügbar: Löschen Sie die Tabelle und erstellen Sie sie noch einmal mit demselben Schema. Legen Sie die Schreibanordnung für die Tabelle auf WRITE_TRUNCATE fest, wenn der Kürzungsvorgang für die angegebene Tabelle ein häufiger Anwendungsfall ist. Verwenden Sie die CREATE OR REPLACE TABLE-Anweisung. Verwenden Sie die DELETE from table_name WHERE 1=1-Anweisung. Hinweis: Bestimmte Partitionen können ebenfalls gekürzt werden. Weitere Informationen finden Sie unter Partition löschen.

CREATE EXTERNAL TABLE- und DROP EXTERNAL TABLE-Anweisungen

Informationen zur Unterstützung externer Tabellen in BigQuery finden Sie unter Einführung in externe Datenquellen.

CREATE VIEW- und DROP VIEW-Anweisungen

Die folgende Tabelle enthält Details zur Konvertierung von CREATE VIEW-Anweisungen aus Hive in BigQuery:

Hive	BigQuery
CREATE VIEW [IF NOT EXISTS] [db_name.]view_name [(column_name [COMMENT column_comment], ...) ] [COMMENT view_comment] [TBLPROPERTIES (property_name = property_value, ...)] AS SELECT ...;	{CREATE VIEW | CREATE VIEW IF NOT EXISTS | CREATE OR REPLACE VIEW} view_name [OPTIONS(view_option_list)] AS query_expression
CREATE MATERIALIZED VIEW [IF NOT EXISTS] [db_name.]materialized_view_name [DISABLE REWRITE] [COMMENT materialized_view_comment] [PARTITIONED ON (col_name, ...)] [ [ROW FORMAT row_format] [STORED AS file_format] | STORED BY 'storage.handler.class.name' [WITH SERDEPROPERTIES (...)] ] [LOCATION hdfs_path] [TBLPROPERTIES (property_name=property_value, ...)] AS ;	CREATE MATERIALIZED VIEW [IF NOT EXISTS] \ [project_id].[dataset_id].materialized_view_name -- cannot disable rewrites in BigQuery [OPTIONS( [description="materialized_view_comment",] \ [other materialized_view_option_list] )] [PARTITION BY (col_name)] --same as source table

CREATE FUNCTION- und DROP FUNCTION-Anweisungen

Die folgende Tabelle enthält Details zur Konvertierung gespeicherter Prozeduren aus Hive in BigQuery:

Hive	BigQuery
CREATE TEMPORARY FUNCTION function_name AS class_name;	CREATE { TEMPORARY | TEMP } FUNCTION function_name ([named_parameter[, ...]]) [RETURNS data_type] AS (sql_expression) named_parameter: param_name param_type
DROP TEMPORARY FUNCTION [IF EXISTS] function_name;	Nicht unterstützt.
CREATE FUNCTION [db_name.]function_name AS class_name [USING JAR|FILE|ARCHIVE 'file_uri' [, JAR|FILE|ARCHIVE 'file_uri'] ];	Wird für Projekte auf der Zulassungsliste als Alpha-Feature unterstützt. CREATE { FUNCTION | FUNCTION IF NOT EXISTS | OR REPLACE FUNCTION } function_name ([named_parameter[, ...]]) [RETURNS data_type] AS (expression); named_parameter: param_name param_type
DROP FUNCTION [IF EXISTS] function_name;	DROP FUNCTION [ IF EXISTS ] function_name
RELOAD FUNCTION;	Nicht unterstützt.

CREATE MACRO- und DROP MACRO-Anweisungen

Die folgende Tabelle enthält Details zur Konvertierung von prozeduralen SQL-Anweisungen, die beim Erstellen eines Makros aus Hive in BigQuery mit variabler Deklaration und Zuweisung verwendet werden:

Hive	BigQuery
CREATE TEMPORARY MACRO macro_name([col_name col_type, ...]) expression;	Nicht unterstützt. In einigen Fällen kann dies durch eine UDF ersetzt werden.
DROP TEMPORARY MACRO [IF EXISTS] macro_name;	Nicht unterstützt.

Fehlercodes und -meldungen

Hive-Fehlercodes und BigQuery-Fehlercodes sind unterschiedlich. Wenn Ihre Anwendungslogik Fehler erkennt, beseitigen Sie die Fehlerquelle, da BigQuery nicht die gleichen Fehlercodes zurückgibt.

In BigQuery ist es üblich, Fehler mithilfe der INFORMATION_SCHEMA-Ansichten oder des Audit-Loggings zu untersuchen.

Konsistenzgarantien und Transaktionsisolation

Sowohl Hive als auch BigQuery unterstützen Transaktionen mit ACID-Semantik. Transaktionen sind in Hive 3 standardmäßig aktiviert.

ACID-Semantik

Hive unterstützt die Snapshot-Isolation. Wenn Sie eine Abfrage ausführen, wird die Abfrage mit einem konsistenten Snapshot der Datenbank bereitgestellt, der bis zum Ende der Ausführung verwendet wird. Hive bietet eine vollständige ACID-Semantik auf Zeilenebene. Damit kann eine Anwendung Zeilen hinzufügen, wenn eine andere Anwendung aus derselben Partition liest, ohne sich gegenseitig zu beeinträchtigen.

BigQuery bietet Snapshot-Isolation für eine optimistische Nebenläufigkeitserkennung (der erste Commit erhält Vorrang), bei der eine Abfrage die letzten übergebenen Daten liest, bevor die Abfrage beginnt. Dieser Ansatz garantiert die gleiche Konsistenz für jede Zeile und Mutation sowie zeilenübergreifend innerhalb derselben DML-Anweisung und vermeidet dabei Deadlocks. Bei mehreren DML-Aktualisierungen für dieselbe Tabelle wechselt BigQuery zur pessimistischen Nebenläufigkeitserkennung. Ladejobs können unabhängig ausgeführt werden und Tabellen anhängen. BigQuery bietet jedoch keine explizite Transaktionsgrenze oder Sitzung.

Transaktionen

Hive unterstützt keine Transaktionen mit mehreren Anweisungen. Die Anweisungen BEGIN, COMMIT und ROLLBACK werden nicht unterstützt. In Hive werden alle Sprachvorgänge automatisch per Commit ausgeführt.

BigQuery unterstützt Transaktionen mit mehreren Anweisungen innerhalb einer einzelnen Abfrage oder über mehrere Abfragen hinweg, wenn Sie Sitzungen verwenden. Mit einer Transaktion mit mehreren Anweisungen können Sie mutierende Vorgänge, z. B. das Einfügen oder Löschen von Zeilen in einer oder mehreren Tabellen, ausführen und entweder die Änderungen übernehmen oder ein Rollback durchführen. Weitere Informationen finden Sie unter Transaktionen mit mehreren Anweisungen.