Guida alla traduzione SQL di Apache Hive

Questo documento descrive in dettaglio le analogie e le differenze nella sintassi SQL tra Apache Hive e BigQuery per aiutarti a pianificare la migrazione. Per eseguire la migrazione collettiva degli script SQL, utilizza la traduzione SQL batch. Per tradurre query ad hoc, utilizza la traduzione SQL interattiva.

In alcuni casi, non esiste una mappatura diretta tra un elemento SQL in Hive e BigQuery. Tuttavia, nella maggior parte dei casi, BigQuery offre un elemento alternativo a Hive per aiutarti a ottenere la stessa funzionalità, come mostrato negli esempi di questo documento.

Il pubblico di destinazione di questo documento è costituito da architetti aziendali, amministratori di database, sviluppatori di applicazioni e specialisti della sicurezza IT. Presuppone che tu abbia familiarità con Hive.

Tipi di dati

Hive e BigQuery hanno sistemi di tipi di dati diversi. Nella maggior parte dei casi, puoi mappare i tipi di dati in Hive ai tipi di dati BigQuery con alcune eccezioni, come MAP e UNION. Hive supporta più conversioni di tipo implicite rispetto a BigQuery. Di conseguenza, il traduttore SQL batch inserisce molti cast espliciti.

Alveare	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 con coppie chiave-valore (campo REPEAT)
UNION	STRUCT con diversi tipi
-	GEOGRAPHY
-	JSON

Sintassi delle query

Questa sezione illustra le differenze nella sintassi delle query tra Hive e BigQuery.

SELECT estratto conto

La maggior parte delle istruzioni Hive SELECT sono compatibili con BigQuery. La seguente tabella contiene un elenco di differenze minori:

Custodia	Alveare	BigQuery
Sottoquery	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 );
Filtro delle colonne	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 );
Espandere un array	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 clausola

La clausola FROM in una query elenca i riferimenti alle tabelle da cui vengono selezionati i dati. In Hive, i possibili riferimenti alle tabelle includono tabelle, viste e sottoquery. BigQuery supporta anche tutti questi riferimenti alle tabelle.

Puoi fare riferimento alle tabelle BigQuery nella clausola FROM utilizzando quanto segue:

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

BigQuery supporta anche riferimenti aggiuntivi alle tabelle:

• Versioni precedenti della definizione e delle righe della tabella utilizzando FOR SYSTEM_TIME AS OF
• Percorsi dei campi o qualsiasi percorso che si risolve in un campo all'interno di un tipo di dati (ad esempio un STRUCT)
• Array appiattiti

Operatori di confronto

La tabella seguente fornisce dettagli sulla conversione degli operatori da Hive a BigQuery:

Funzione o operatore	Alveare	BigQuery
- Meno unario * Moltiplicazione / Divisione + Addizione - Sottrazione	Tutti i tipi di numeri	Tutti i tipi di numeri. Per evitare errori durante l'operazione di divisione, valuta la possibilità di utilizzare SAFE_DIVIDE o IEEE_DIVIDE.
~ NOT bit a bit | OR bit a bit & AND bit a bit ^ XOR bit a bit	Tipo di dati booleano	Tipo di dati booleano.
Maiusc sinistro	shiftleft(TINYINT|SMALLINT|INT a, INT b) shiftleft(BIGINT a, INT b)	<< Numero intero o byte A << B, dove B deve essere dello stesso tipo di A
Maiusc destro	shiftright(TINYINT|SMALLINT|INT a, INT b) shiftright(BIGINT a, INT b)	>> Numero intero o byte A >> B, dove B deve essere dello stesso tipo di A
Modulo (resto)	X % Y Tutti i tipi di numeri	MOD(X, Y)
Divisione intera	A DIV B e A/B per una precisione dettagliata	Tutti i tipi di numeri. Nota: per evitare errori durante l'operazione di divisione, valuta la possibilità di utilizzare SAFE_DIVIDE o IEEE_DIVIDE.
Negazione unaria	!, NOT	NOT
Tipi che supportano i confronti di uguaglianza	Tutti i tipi primitivi	Tutti i tipi comparabili e STRUCT.
	a <=> b	Non supportati. Traduci in: (a = b AND b IS NOT NULL OR a IS NULL)
	a <> b	Non supportati. Traduci in: NOT (a = b AND b IS NOT NULL OR a IS NULL)
Operatori relazionali ( =, ==, !=, <, >, >= )	Tutti i tipi primitivi	Tutti i tipi paragonabili.
Confronto tra stringhe	RLIKE, REGEXP	Funzione integrata REGEXP_CONTAINS. Utilizza la sintassi delle espressioni regolari di BigQuery per le funzioni stringa per i pattern delle espressioni regolari.
[NOT] LIKE, [NOT] BETWEEN, IS [NOT] NULL	A [NOT] BETWEEN B AND C, A IS [NOT] (TRUE|FALSE), A [NOT] LIKE B	Uguale a Hive. Inoltre, BigQuery supporta anche l'operatore IN.

Condizioni JOIN

Sia Hive che BigQuery supportano i seguenti tipi di join:

• [INNER] JOIN

• LEFT [OUTER] JOIN

• RIGHT [OUTER] JOIN

• FULL [OUTER] JOIN

• CROSS JOIN e il cross join con virgola implicito equivalente

Per saperne di più, consulta Operazione di join e Join Hive.

Conversione e casting dei tipi

La tabella seguente fornisce dettagli sulla conversione delle funzioni da Hive a BigQuery:

Funzione o operatore	Alveare	BigQuery
Conversione del tipo	Quando un cast non va a buon fine, viene restituito `NULL`.	Stessa sintassi di Hive. Per ulteriori informazioni sulle regole di conversione dei tipi di BigQuery, consulta Regole di conversione. Se la trasmissione non riesce, viene visualizzato un errore. Per avere lo stesso comportamento di Hive, utilizza SAFE_CAST.
SAFE chiamate di funzione		Se anteponi alle chiamate di funzione SAFE, la funzione restituisce NULL anziché segnalare un errore. Ad esempio, SAFE.SUBSTR('foo', 0, -2) AS safe_output; restituisce NULL. Nota: quando trasmetti in modo sicuro e senza errori, utilizza SAFE_CAST.

Tipi di conversione impliciti

Quando esegui la migrazione a BigQuery, devi convertire la maggior parte delle conversioni implicite di Hive in conversioni esplicite di BigQuery, ad eccezione dei seguenti tipi di dati, che BigQuery converte implicitamente.

Dal tipo BigQuery	To BigQuery type
INT64	FLOAT64, NUMERIC, BIGNUMERIC
BIGNUMERIC	FLOAT64
NUMERIC	BIGNUMERIC, FLOAT64

BigQuery esegue anche conversioni implicite per i seguenti valori letterali:

Dal tipo BigQuery	To BigQuery type
STRING letterale (ad esempio, "2008-12-25")	DATE
STRING letterale (ad esempio, "2008-12-25 15:30:00")	TIMESTAMP
STRING letterale (ad esempio, "2008-12-25T07:30:00")	DATETIME
STRING letterale (ad esempio, "15:30:00")	TIME

Tipi di conversione espliciti

Se vuoi convertire i tipi di dati Hive che BigQuery non converte implicitamente, utilizza la funzione CAST(expression AS type) BigQuery.

Funzioni

Questa sezione illustra le funzioni comuni utilizzate in Hive e BigQuery.

Funzioni di aggregazione

La seguente tabella mostra i mapping tra le funzioni di aggregazione, aggregazione statistica e aggregazione approssimativa comuni di Hive e i relativi equivalenti BigQuery:

Alveare	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 non supporta gli altri argomenti definiti da Hive.
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

Funzioni analitiche

La tabella seguente mostra i mapping tra le funzioni analitiche Hive comuni e i relativi equivalenti BigQuery:

Alveare	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	È possibile utilizzare una funzione definita dall'utente dall'utente.

Funzioni di data e ora

La tabella seguente mostra i mapping tra le funzioni di data e ora di Hive comuni e i relativi equivalenti BigQuery:

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 è consigliato, in quanto questo valore è indipendente dal fuso orario e sinonimo di CURRENT_TIMESTAMP \ CURRENT_TIMESTAMP in Hive.
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 offre le seguenti funzioni aggiuntive per data e ora:

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

Funzioni di stringa

La tabella seguente mostra i mapping tra le funzioni stringa di Hive e i relativi equivalenti BigQuery:

Alveare	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 offre le seguenti funzioni stringa aggiuntive:

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

Funzioni matematiche

La tabella seguente mostra i mapping tra le funzioni matematiche di Hive e i relativi equivalenti BigQuery:

Alveare	BigQuery
ABS	ABS
ACOS	ACOS
ASIN	ASIN
ATAN	ATAN
CEIL	CEIL
CEILING	CEILING
COS	COS
FLOOR	FLOOR
GREATEST	GREATEST
LEAST	LEAST
LN	LN
LNNVL	Utilizza con ISNULL.
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 offre le seguenti funzioni matematiche aggiuntive:

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

Funzioni logiche e condizionali

La tabella seguente mostra i mapping tra le funzioni logiche e condizionali di Hive e i relativi equivalenti BigQuery:

Alveare	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

UDF e UDAF

Apache Hive supporta la scrittura di funzioni definite dall'utente (UDF) in Java. Puoi caricare le funzioni definite dall'utente in Hive per utilizzarle nelle query regolari. Le UDF BigQuery devono essere scritte in GoogleSQL o JavaScript. La conversione delle UDF Hive in UDF SQL è consigliata perché le UDF SQL hanno prestazioni migliori. Se devi utilizzare JavaScript, leggi le best practice per le UDF JavaScript. Per le altre lingue, BigQuery supporta le funzioni remote che consentono di richiamare le funzioni in Cloud Run Functions o Cloud Run dalle query GoogleSQL.

BigQuery non supporta le funzioni di aggregazione definite dall'utente (UDAF).

Sintassi DML

Questa sezione illustra le differenze nella sintassi del data manipulation language (DML) tra Hive e BigQuery.

INSERT estratto conto

La maggior parte delle istruzioni Hive INSERT è compatibile con BigQuery. La tabella seguente mostra le eccezioni:

Alveare	BigQuery
INSERT INTO TABLE tablename [PARTITION (partcol1[=val1], partcol2[=val2] ...)] VALUES values_row [, values_row ...]	INSERT INTO table (...) VALUES (...); Nota: in BigQuery, l'omissione dei nomi delle colonne nell'istruzione INSERT funziona solo se i valori per tutte le colonne della tabella di destinazione sono inclusi in ordine crescente in base alle loro posizioni ordinali.
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 non supporta le operazioni di inserimento e sovrascrittura. È possibile eseguire la migrazione di questa sintassi Hive alle istruzioni TRUNCATE e INSERT.

BigQuery impone quote DML che limitano il numero di istruzioni DML che puoi eseguire giornalmente. Per utilizzare al meglio la quota, prendi in considerazione i seguenti approcci:

• Combina più righe in una singola istruzione INSERT, anziché una riga per ogni operazione INSERT.

• Combina più istruzioni DML (inclusa INSERT) utilizzando un'istruzione MERGE.

• Usa CREATE TABLE ... AS SELECT per creare e compilare nuove tabelle.

UPDATE estratto conto

La maggior parte delle istruzioni Hive UPDATE è compatibile con BigQuery. La tabella seguente mostra le eccezioni:

Alveare	BigQuery
UPDATE tablename SET column = value [, column = value ...] [WHERE expression]	UPDATE table SET column = expression [,...] [FROM ...] WHERE TRUE Nota: tutte le istruzioni UPDATE in BigQuery richiedono una parola chiave WHERE, seguita da una condizione.

DELETE e TRUNCATE

Puoi utilizzare le istruzioni DELETE o TRUNCATE per rimuovere righe da una tabella senza influire sullo schema o sugli indici della tabella.

In BigQuery, l'istruzione DELETE deve avere una clausola WHERE. Per ulteriori informazioni su DELETE in BigQuery, vedi DELETE esempi.

Alveare	BigQuery
DELETE FROM tablename [WHERE expression]	DELETE FROM table_name WHERE TRUE Le istruzioni BigQuery DELETE richiedono una clausola WHERE .
TRUNCATE [TABLE] table_name [PARTITION partition_spec];	TRUNCATE TABLE [[project_name.]dataset_name.]table_name

MERGE estratto conto

L'istruzione MERGE può combinare le operazioni INSERT, UPDATE e DELETE in un'unica istruzione upsert ed eseguire le operazioni. L'operazione MERGE deve corrispondere al massimo a una riga di origine per ogni riga di destinazione.

Alveare	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, ... Nota: devi elencare tutte le colonne che devono essere aggiornate.

ALTER estratto conto

La tabella seguente fornisce dettagli sulla conversione delle istruzioni CREATE VIEW da Hive a BigQuery:

Funzione	Alveare	BigQuery
Rename table	ALTER TABLE table_name RENAME TO new_table_name;	Non supportati. Una soluzione alternativa consiste nell'utilizzare un job di copia con il nome che vuoi assegnare alla tabella di destinazione, quindi eliminare quella precedente. 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, ... )	La serializzazione e la deserializzazione sono gestite dal servizio BigQuery e non sono configurabili dall'utente. Per scoprire come consentire a BigQuery di leggere i dati da file CSV, JSON, AVRO, PARQUET o ORC, consulta Creare tabelle esterne di Cloud Storage. Supporta i formati di esportazione CSV, JSON, AVRO e PARQUET. Per saperne di più, consulta Formati di esportazione e tipi di compressione.
Table storage properties	ALTER TABLE table_name CLUSTERED BY (col_name, col_name, ...) [SORTED BY (col_name, ...)] INTO num_buckets BUCKETS;	Non supportato per i prospetti ALTER.
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", ...] );	Il bilanciamento dell'archiviazione per le query sulle prestazioni è gestito dal servizio BigQuery e non è configurabile.
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; Per ulteriori informazioni, consulta la dichiarazione ALTER TABLE ADD PRIMARY KEY.
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, ...)	Non supportati. Le partizioni aggiuntive vengono aggiunte in base alle necessità quando vengono caricati i dati con nuovi valori nelle colonne di partizione. Per saperne di più, consulta Gestione delle tabelle partizionate.
Rename partition	ALTER TABLE table_name PARTITION partition_spec RENAME TO PARTITION partition_spec;	Non supportati.
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;	Non supportati.
Recover partition	MSCK [REPAIR] TABLE table_name [ADD/DROP/SYNC PARTITIONS];	Non supportati.
Drop partition	ALTER TABLE table_name DROP [IF EXISTS] PARTITION partition_spec[, PARTITION partition_spec, ...] [IGNORE PROTECTION] [PURGE];	Supportato utilizzando i seguenti metodi: bq rm 'mydataset.table_name$partition_id' DELETE from table_name$partition_id WHERE 1=1 Per saperne di più, vedi Eliminare una partizione.
(Un)Archive partition	ALTER TABLE table_name ARCHIVE PARTITION partition_spec; ALTER TABLE table_name UNARCHIVE PARTITION partition_spec;	Non supportati.
Table and partition file format	ALTER TABLE table_name [PARTITION partition_spec] SET FILEFORMAT file_format;	Non supportati.
Table and partition location	ALTER TABLE table_name [PARTITION partition_spec] SET LOCATION "new location";	Non supportati.
Table and partition touch	ALTER TABLE table_name TOUCH [PARTITION partition_spec];	Non supportati.
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;	Non supportati.
Table and partition compact	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] COMPACT 'compaction_type'[AND WAIT] [WITH OVERWRITE TBLPROPERTIES ("property"="value" [, ...])];	Non supportati.
Table and artition concatenate	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] CONCATENATE;	Non supportati.
Table and partition columns	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] UPDATE COLUMNS;	Non supportato per gli estratti conto ALTER TABLE.
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];	Non supportati.

Sintassi DDL

Questa sezione illustra le differenze nella sintassi DDL (Data Definition Language) tra Hive e BigQuery.

CREATE TABLE e DROP TABLE

La tabella seguente fornisce dettagli sulla conversione delle istruzioni CREATE TABLE da Hive a BigQuery:

Tipo	Alveare	BigQuery
Tabelle gestite	create table table_name ( id int, dtDontQuery string, name string )	CREATE TABLE `myproject`.mydataset.table_name ( id INT64, dtDontQuery STRING, name STRING )
Tabelle partizionate	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 Quando esegui il partizionamento per data, rimuovi il commento dalle seguenti righe: PARTITION BY dt OPTIONS( description="Table Description", Quando esegui il partizionamento per data, rimuovi il commento dalle seguenti righe. Ti consigliamo di utilizzare require_partition quando la tabella è partizionata. 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: La forma LIKE di CREATE TABLE consente di copiare esattamente una definizione di tabella esistente.	CREATE TABLE empty_key_value_store LIKE key_value_store [TBLPROPERTIES (property_name=property_value, ...)];	Non supportati.
Tabelle ordinate in bucket (in cluster nella terminologia BigQuery)	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 )' Per saperne di più, vedi Creare e utilizzare tabelle in cluster.
Tabelle distorte (tabelle in cui una o più colonne hanno valori distorti)	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];	Non supportati.
Tabelle temporanee	CREATE TEMPORARY TABLE list_bucket_multiple ( col1 STRING, col2 int, col3 STRING);	Puoi ottenere questo risultato utilizzando il tempo di scadenza nel seguente modo: 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")] )
Tabelle transazionali	CREATE TRANSACTIONAL TABLE transactional_table_test(key string, value string) PARTITIONED BY(ds string) STORED AS ORC;	Tutte le modifiche alle tabelle in BigQuery sono conformi ad ACID (atomicità, coerenza, isolamento, durabilità).
Elimina tabella	DROP TABLE [IF EXISTS] table_name [PURGE];	{DROP TABLE | DROP TABLE IF EXISTS} table_name
Tronca tabella	TRUNCATE TABLE table_name [PARTITION partition_spec]; partition_spec: : (partition_column = partition_col_value, partition_column = partition_col_value, ...)	Non supportati. Sono disponibili le seguenti soluzioni alternative: Elimina e crea di nuovo la tabella con lo stesso schema. Imposta la disposizione di scrittura per la tabella su WRITE_TRUNCATE se l'operazione di troncamento è un caso d'uso comune per la tabella specificata. Utilizza l'istruzione CREATE OR REPLACE TABLE. Utilizza l'istruzione DELETE from table_name WHERE 1=1. Nota: anche partizioni specifiche possono essere troncate. Per saperne di più, vedi Eliminare una partizione.

CREATE EXTERNAL TABLE e DROP EXTERNAL TABLE

Per il supporto delle tabelle esterne in BigQuery, consulta Introduzione alle origini dati esterne.

CREATE VIEW e DROP VIEW

La tabella seguente fornisce dettagli sulla conversione delle istruzioni CREATE VIEW da Hive a BigQuery:

Alveare	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 e DROP FUNCTION

La tabella seguente fornisce dettagli sulla conversione delle stored procedure da Hive a BigQuery:

Alveare	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;	Non supportati.
CREATE FUNCTION [db_name.]function_name AS class_name [USING JAR|FILE|ARCHIVE 'file_uri' [, JAR|FILE|ARCHIVE 'file_uri'] ];	Supportato per i progetti consentiti come funzionalità alpha. 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;	Non supportati.

CREATE MACRO e DROP MACRO

La seguente tabella fornisce i dettagli sulla conversione delle istruzioni SQL procedurali utilizzate per creare macro da Hive a BigQuery con dichiarazione e assegnazione di variabili:

Alveare	BigQuery
CREATE TEMPORARY MACRO macro_name([col_name col_type, ...]) expression;	Non supportati. In alcuni casi, può essere sostituito con una UDF.
DROP TEMPORARY MACRO [IF EXISTS] macro_name;	Non supportati.

Codici e messaggi di errore

I codici di errore di Hive e i codici di errore di BigQuery sono diversi. Se la logica dell'applicazione rileva errori, elimina l'origine dell'errore perché BigQuery non restituisce gli stessi codici di errore.

In BigQuery, è comune utilizzare le viste INFORMATION_SCHEMA o la registrazione degli audit per esaminare gli errori.

Garanzie di coerenza e isolamento delle transazioni

Sia Hive che BigQuery supportano le transazioni con semantica ACID. Le transazioni sono attive per impostazione predefinita in Hive 3.

Semantica ACID

Hive supporta l'isolamento degli snapshot. Quando esegui una query, viene fornito uno snapshot coerente del database, che viene utilizzato fino al termine dell'esecuzione. Hive fornisce la semantica ACID completa a livello di riga, consentendo a un'applicazione di aggiungere righe quando un'altra applicazione legge dalla stessa partizione senza interferire tra loro.

BigQuery fornisce il controllo della concorrenza ottimistico (il primo commit vince) con l'isolamento degli snapshot, in cui una query legge gli ultimi dati di cui è stato eseguito il commit prima dell'inizio della query. Questo approccio garantisce lo stesso livello di coerenza per ogni riga e mutazione e tra le righe all'interno della stessa istruzione DML, evitando i deadlock. Per più aggiornamenti DML alla stessa tabella, BigQuery passa al controllo della concorrenza pessimistico. I job di caricamento possono essere eseguiti in modo indipendente e aggiungere tabelle. Tuttavia, BigQuery non fornisce un limite di transazione o una sessione espliciti.

Transazioni

Hive non supporta le transazioni con più istruzioni. Non supporta le istruzioni BEGIN, COMMIT e ROLLBACK. In Hive, tutte le operazioni di linguaggio vengono eseguite automaticamente.

BigQuery supporta le transazioni con più istruzioni all'interno di una singola query o in più query quando utilizzi le sessioni. Una transazione multi-istruzione consente di eseguire operazioni mutanti, come l'inserimento o l'eliminazione di righe da una o più tabelle e di eseguire il commit o il rollback delle modifiche. Per maggiori informazioni, consulta la sezione Transazioni con più estratti conto.