Guida alla traduzione SQL di Apache Hive

Questo documento descrive le somiglianze e le differenze nella sintassi SQL tra Apache Hive e BigQuery per aiutarti a pianificare la tua migrazione. Per eseguire la migrazione in blocco 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.

I destinatari di questo documento sono architetti aziendali, amministratori di database, sviluppatori di applicazioni ed esperti della sicurezza IT. Suppone 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, ad esempio MAP e UNION. Hive supporta la trasmissione di tipi più implicita 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 tipi diversi
-	GEOGRAPHY
-	JSON

Sintassi delle query

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

Istruzione SELECT

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

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 );
Esplodere 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 tabella 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:

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

BigQuery supporta anche ulteriori riferimenti alle tabelle:

• Versioni storiche della definizione della tabella e delle righe utilizzando FOR SYSTEM_TIME AS OF
• Percorsi dei campi o qualsiasi percorso che si risolva in un campo 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	Alveare	BigQuery
- Meno unitario * Moltiplicazione / Divisione + Aggiunta - Sottrazione	Tutti i tipi di numeri	Tutti i tipi di numeri. Per evitare errori durante l'operazione di divisione, puoi utilizzare SAFE_DIVIDE o IEEE_DIVIDE.
~ a bit non a livello di bit | a livello di bit O & a livello di bit E ^ XOR a livello di bit	Tipo di dati booleano	Tipo di dati booleano.
Maiusc a sinistra	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 a destra	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 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, puoi utilizzare SAFE_DIVIDE o IEEE_DIVIDE.
Negazione unaria	!, NOT	NOT
Tipi a supporto dei confronti sulle pari opportunità	Tutti i tipi primitivi	Tutti i tipi paragonabili e STRUCT.
	a <=> b	Non supportati. Traduci quanto segue: (a = b AND b IS NOT NULL OR a IS NULL)
	a <> b	Non supportati. Traduci quanto segue: NOT (a = b AND b IS NOT NULL OR a IS NULL)
Operatori relazionali ( =, ==, !=, <, >, >= )	Tutti i tipi primitivi	Tutti i tipi paragonabili.
Confronto stringhe	RLIKE, REGEXP	Funzione integrata di REGEXP_CONTAINS. Utilizza la sintassi regex per le funzioni 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 Hive. 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 comma cross join implicito equivalente

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

Tipo di conversione e trasmissione

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

Funzione o operatore	Alveare	BigQuery
Tipo di trasmissione	Quando una trasmissione non va a buon fine, viene restituito "NULL".	Stessa sintassi di Hive. Per saperne di più sulle regole di conversione per i tipi BigQuery, consulta Regole di conversione. Se la trasmissione non va a buon fine, viene visualizzato un errore. Per avere lo stesso comportamento di Hive, usa invece SAFE_CAST.
Chiamate di funzione SAFE		Se aggiungi il prefisso SAFE alle chiamate di funzione, la funzione restituisce NULL anziché segnalare l'errore. Ad esempio, SAFE.SUBSTR('foo', 0, -2) AS safe_output; restituisce NULL. Nota: quando trasmetti in modo sicuro senza errori, usa SAFE_CAST.

Tipi di conversione impliciti

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

Dal tipo BigQuery	Come digitare BigQuery
INT64	FLOAT64, NUMERIC, BIGNUMERIC
BIGNUMERIC	FLOAT64
NUMERIC	BIGNUMERIC, FLOAT64

BigQuery esegue anche conversioni implicite per i seguenti valori letterali:

Dal tipo BigQuery	Come digitare 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 tipi di dati Hive che BigQuery non converte implicitamente, utilizza la funzione CAST(expression AS type) di BigQuery o una delle funzioni di conversione DATE e TIMESTAMP.

Funzioni

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

Funzioni di aggregazione

La seguente tabella mostra le mappature tra funzioni aggregate Hive comuni, di aggregazione statistica e di aggregazione approssimata con i rispettivi 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 seguente tabella mostra le mappature tra funzioni analitiche Hive comuni con 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 seguente tabella mostra le mappature tra le funzioni comuni di data e ora di Hive 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, perché questo valore è senza 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 di 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 seguente tabella mostra le mappature tra le funzioni stringa 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 seguente tabella mostra le mappature tra le funzioni matematiche Hive e i rispettivi 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	Da usare 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 seguente tabella mostra le mappature tra 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

Funzioni definite dall'utente e funzioni definite dall'utente

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

Sintassi DML

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

Istruzione INSERT

La maggior parte delle istruzioni INSERT Hive è 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 di tutte le colonne nella 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. È possibile eseguire la migrazione di questa sintassi Hive alle istruzioni TRUNCATE e INSERT.

BigQuery impone delle quote DML che limitano il numero di istruzioni DML che puoi eseguire ogni giorno. Per sfruttare al meglio la quota, considera questi approcci:

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

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

• Utilizza CREATE TABLE ... AS SELECT per creare e completare nuove tabelle.

Istruzione UPDATE

La maggior parte delle istruzioni UPDATE Hive è 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.

Estratti conto 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 gli esempi di DELETE.

Alveare	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

Istruzione MERGE

L'istruzione MERGE può combinare le operazioni INSERT, UPDATE e DELETE in una singola 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.

Istruzione ALTER

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 usare come tabella di destinazione, quindi eliminare il 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 è configurabile dall'utente. Per scoprire come consentire a BigQuery di leggere i dati dei file CSV, JSON, AVRO, PARQUET o ORC, vedi Creare tabelle esterne di Cloud Storage. Supporta i formati di esportazione CSV, JSON, AVRO e PARQUET. Per ulteriori informazioni, vedi 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 supportata per gli estratti conto 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 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 saperne di più, consulta l'Informativa su 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. Quando vengono caricati dati con nuovi valori nelle colonne di partizione, vengono aggiunte altre partizioni necessarie. 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];	Supportati con i seguenti metodi: bq rm 'mydataset.table_name$partition_id' DELETE from table_name$partition_id WHERE 1=1 Per ulteriori informazioni, 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 supportata 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.

Estratti conto 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 da quanto segue: PARTITION BY dt OPTIONS( description="Table Description", Quando esegui il partizionamento per data, rimuovi il commento da quanto segue. Si consiglia 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: Il formato 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 disallineate (tabelle in cui una o più colonne hanno valori disallineati)	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 farlo utilizzando l'ora 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: Trascina e crea di nuovo la tabella con lo stesso schema. Imposta l'istruzione 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 le partizioni specifiche possono essere troncate. Per ulteriori informazioni, vedi Eliminare una partizione.

Estratti conto CREATE EXTERNAL TABLE e DROP EXTERNAL TABLE

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

Estratti conto 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

Estratti conto 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'] ];	Supportata per i progetti 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 supportati.

Estratti conto CREATE MACRO e DROP MACRO

La seguente tabella fornisce dettagli sulla conversione delle istruzioni SQL procedurali utilizzate nella creazione di 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, questa può essere sostituita con una funzione definita dall'utente.
DROP TEMPORARY MACRO [IF EXISTS] macro_name;	Non supportati.

Codici e messaggi di errore

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

In BigQuery, è comune utilizzare le viste INFORMATION_SCHEMA o l'audit logging per esaminare gli errori.

Garanzie di coerenza e isolamento delle transazioni

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

Semantica ACID

Hive supporta l'isolamento degli snapshot. Quando esegui una query, questa viene fornita con uno snapshot coerente del database, che utilizza fino alla fine 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 offre un controllo della contemporaneità ottimistico (il primo commit delle vincite) con l'isolamento dello 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 righe all'interno della stessa istruzione DML, evitando i deadlock. In caso di più aggiornamenti DML alla stessa tabella, BigQuery passa al controllo della contemporaneità 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ù dichiarazioni. Non supporta le istruzioni BEGIN, COMMIT e ROLLBACK. In Hive, tutte le operazioni relative alle lingue vengono eseguite automaticamente.

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