Guida alla traduzione SQL di Apache Hive

Questo documento illustra le somiglianze 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 collettiva. Per tradurre le 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. Assume 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 un maggior numero di conversioni di tipo implicite rispetto a BigQuery. Di conseguenza, il traduttore SQL batch inserisce molti tipi espliciti.

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 con valori chiave (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 dichiarazione

La maggior parte delle istruzioni SELECT Hive è compatibile con BigQuery. La tabella seguente contiene un elenco di piccole differenze:

Richiesta	Hive	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;

Clausola FROM

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 ulteriori riferimenti a tabelle:

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

Operatori di confronto

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

Funzione o operatore	Hive	BigQuery
- Sottrazione unaria * 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.
~ NON a livello di bit | OR a livello di bit & AND a livello di bit ^ XOR a livello di 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 (residuo)	X % Y Tutti i tipi di numeri	MOD(X, Y)
Divisione di numeri interi	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 paragonabili e STRUCT.
	a <=> b	Non supportato. Traduci nel seguente modo: (a = b AND b IS NOT NULL OR a IS NULL)
	a <> b	Non supportato. Traduci nel seguente modo: NOT (a = b AND b IS NOT NULL OR a IS NULL)
Operatori relazionali ( =, ==, !=, <, >, >= )	Tutti i tipi primitivi	Tutti i tipi paragonabili.
Confronto di stringhe	RLIKE, REGEXP	Funzione integrata REGEXP_CONTAINS. Utilizza la sintassi regex per le funzioni di stringa di BigQuery per i pattern di espressioni regolari.
[NOT] LIKE, [NOT] BETWEEN, IS [NOT] NULL	A [NOT] BETWEEN B AND C, A IS [NOT] (TRUE|FALSE), A [NOT] LIKE B	Come per 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 l'equivalente join con virgola implicito

Per ulteriori informazioni, consulta Operazione di join e Join Hive.

Conversione e trasmissione di tipi

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

Funzione o operatore	Hive	BigQuery
Tipizzazione	Quando una trasmissione 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.
Chiamate di funzioni SAFE		Se anteponi alle chiamate alle funzioni il prefisso 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 sicurezza senza errori, utilizza SAFE_CAST.

Tipi di conversione implicita

Durante 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 in modo implicito.

Dal tipo BigQuery	Al tipo BigQuery
INT64	FLOAT64, NUMERIC, BIGNUMERIC
BIGNUMERIC	FLOAT64
NUMERIC	BIGNUMERIC, FLOAT64

BigQuery esegue anche conversioni implicite per i seguenti letterali:

Dal tipo BigQuery	Al tipo BigQuery
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 convertiene implicitamente, utilizza la funzione CAST(expression AS type) di BigQuery.

Funzioni

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

Funzioni di aggregazione

La seguente tabella mostra le mappature tra le funzioni aggregate, di aggregazione statistica e di approssimazione comuni di Hive e i relativi equivalenti di BigQuery:

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 non supporta il resto degli 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 di analisi

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

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

Funzioni di data e ora

La tabella seguente mostra le mappature tra le funzioni di data e ora 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 non è associato a un fuso orario ed è 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 date e ore:

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 le mappature tra le funzioni di stringa Hive e i relativi equivalenti BigQuery:

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 offre le seguenti funzioni di 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 le mappature tra le funzioni matematiche di Hive e i relativi equivalenti di BigQuery:

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	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 le mappature tra le funzioni logiche e condizionali di Hive e i relativi equivalenti di BigQuery:

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

Funzioni definite dall'utente e funzioni definite dall'utente

BigQuery supporta le funzioni UDF, ma non le funzioni aggregate definite dall'utente (UDAF).

Sintassi DML

Questa sezione illustra le differenze nella sintassi del linguaggio di manipolazione dei dati (DML) tra Hive e BigQuery.

INSERT dichiarazione

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

Hive	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 di tutte le colonne della tabella di destinazione sono inclusi in ordine crescente in base alle relative 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. Questa sintassi Hive può essere migrata alle istruzioni TRUNCATE e INSERT.

BigQuery impone quote DML che limitano il numero di istruzioni DML che puoi eseguire ogni giorno. Per fare un uso migliore della quota, valuta i seguenti approcci:

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

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

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

UPDATE dichiarazione

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

Hive	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.

Dichiarazioni 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, consulta Esempi di DELETE.

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

MERGE dichiarazione

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 a una riga di origine al massimo per ogni riga di destinazione.

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

ALTER dichiarazione

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

Funzione	Hive	BigQuery
Rename table	ALTER TABLE table_name RENAME TO new_table_name;	Non supportato. Una soluzione alternativa è utilizzare un job di copia con il nome che preferisci come tabella di destinazione ed 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 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 le istruzioni 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 dello spazio di archiviazione per le query sul rendimento è 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 supportato. Le partizioni aggiuntive vengono aggiunte in base alle esigenze quando vengono caricati i dati con nuovi valori nelle colonne di partizione. Per ulteriori informazioni, consulta Gestire le tabelle partizionate.
Rename partition	ALTER TABLE table_name PARTITION partition_spec RENAME TO PARTITION partition_spec;	Non supportato.
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 supportato.
Recover partition	MSCK [REPAIR] TABLE table_name [ADD/DROP/SYNC PARTITIONS];	Non supportato.
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 ulteriori informazioni, consulta la sezione Eliminare una partizione.
(Un)Archive partition	ALTER TABLE table_name ARCHIVE PARTITION partition_spec; ALTER TABLE table_name UNARCHIVE PARTITION partition_spec;	Non supportato.
Table and partition file format	ALTER TABLE table_name [PARTITION partition_spec] SET FILEFORMAT file_format;	Non supportato.
Table and partition location	ALTER TABLE table_name [PARTITION partition_spec] SET LOCATION "new location";	Non supportato.
Table and partition touch	ALTER TABLE table_name TOUCH [PARTITION partition_spec];	Non supportato.
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 supportato.
Table and partition compact	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] COMPACT 'compaction_type'[AND WAIT] [WITH OVERWRITE TBLPROPERTIES ("property"="value" [, ...])];	Non supportato.
Table and artition concatenate	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] CONCATENATE;	Non supportato.
Table and partition columns	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] UPDATE COLUMNS;	Non supportato per le istruzioni 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 supportato.

Sintassi DDL

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

Dichiarazioni CREATE TABLE e DROP TABLE

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

Tipo	Hive	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 da quanto segue: PARTITION BY dt OPTIONS( description="Table Description", Quando esegui il partizionamento per data, rimuovi il commento dal codice seguente. 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 supportato.
Tabelle ordinate in bucket (in cluster nella terminologia di 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 ulteriori informazioni, vedi Creare e utilizzare tabelle clusterizzate.
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 supportato.
Tabelle temporanee	CREATE TEMPORARY TABLE list_bucket_multiple ( col1 STRING, col2 int, col3 STRING);	Puoi farlo utilizzando la data e l'ora di scadenza come segue: 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 supportato. Sono disponibili le seguenti soluzioni alternative: Elimina e crea di nuovo la tabella con lo stesso schema. Imposta l'impostazione di destinazione della 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: è possibile troncare anche partizioni specifiche. Per ulteriori informazioni, consulta la sezione Eliminare una partizione.

Dichiarazioni CREATE EXTERNAL TABLE e DROP EXTERNAL TABLE

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

Dichiarazioni CREATE VIEW e DROP VIEW

La tabella seguente fornisce dettagli sulla conversione delle istruzioni CREATE VIEW da Hive a 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

Dichiarazioni CREATE FUNCTION e DROP FUNCTION

La tabella seguente fornisce dettagli sulla conversione delle stored procedure da Hive a 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;	Non supportato.
CREATE FUNCTION [db_name.]function_name AS class_name [USING JAR|FILE|ARCHIVE 'file_uri' [, JAR|FILE|ARCHIVE 'file_uri'] ];	Supportata per i progetti inclusi nella lista consentita 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 supportato.

Dichiarazioni CREATE MACRO e DROP MACRO

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

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

Messaggi e codici di errore

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

In BigQuery, è comune utilizzare le viste INFORMATION_SCHEMA o i log di controllo per esaminare gli errori.

Garanzie di coerenza e isolamento delle transazioni

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

Semantica ACID

Hive supporta l'isolamento degli snapshot. Quando esegui una query, a questa viene fornito uno snapshot coerente del database, che viene utilizzato fino al termine dell'esecuzione. Hive fornisce una 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 sottoposti a 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 al contempo 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 accodare le tabelle. Tuttavia, BigQuery non fornisce un confine o una sessione di transazioni espliciti.

Transazioni

Hive non supporta le transazioni con più istruzioni. Non supporta le istruzioni BEGIN, COMMIT e ROLLBACK. In Hive, tutte le operazioni linguistiche vengono sottoposte a commit automatico.

BigQuery supporta le transazioni con più istruzioni all'interno di una singola query o in più query quando utilizzi le sessioni. Una transazione con più istruzioni consente di eseguire operazioni di mutazione, ad esempio l'inserimento o l'eliminazione di righe da una o più tabelle e l'applicazione del commit o il rollback delle modifiche. Per ulteriori informazioni, consulta la sezione Transazioni con più istruzioni.