Guida alla traduzione SQL Apache Hive

Questo documento descrive 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 in batch. 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 ad Hive per aiutarti a ottenere la stessa funzionalità, come mostrato negli esempi di questo documento.

Il pubblico di destinazione di questo documento è costituito da enterprise architect, 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 di BigQuery con alcune eccezioni, ad esempio MAP e UNION. Hive supporta più trasmissione di tipo 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 nella sintassi delle query tra Hive e BigQuery.

Istruzione SELECT

La maggior parte delle istruzioni SELECT di Hive è compatibile 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 );
Esplosione di 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 della 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 quanto segue:

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

BigQuery supporta anche riferimenti di tabelle aggiuntivi:

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

Operatori di confronto

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

Funzione o operatore	Alveare	BigQuery
- Unaria meno * Moltiplicazione / Divisione + Aggiunta - 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.
~ A livello di bit non | A livello di bit O & A livello di bit E ^ 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 (resto)	X % Y Tutti i tipi di numeri	MOD(X, Y)
Divisione numero intero	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 supportati. Traduci nel seguente modo: (a = b AND b IS NOT NULL OR a IS NULL)
	a <> b	Non supportati. 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 stringhe	RLIKE, REGEXP	Funzione integrata REGEXP_CONTAINS. Utilizza la sintassi regex di BigQuery per le funzioni stringa per i modelli 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 in 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 della virgola implicito equivalente

Per maggiori informazioni, consulta Operazioni di join e join ad Hive.

Digita conversione e trasmissione

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

Funzione o operatore	Alveare	BigQuery
Digitazione della trasmissione	In caso di errore di trasmissione, viene restituito "NULL".	Stessa sintassi di Hive. Per saperne di più sulle regole di conversione del tipo 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 SAFE_CAST.
SAFE chiamate di funzione		Se anteponi 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: se trasmetti in modo sicuro senza errori, usa SAFE_CAST.

Tipi di conversione implicita

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

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

BigQuery esegue anche conversioni implicite per i seguenti valori letterali:

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

Tipi di conversione esplicita

Se vuoi convertire i tipi di dati Hive che BigQuery non converti 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 le funzioni di aggregazione comune di Hive, di aggregazione statistica e di aggregazione approssimativa con 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 seguente tabella mostra le mappature tra le funzioni analitiche comuni di Hive 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 seguente tabella mostra le mappature tra le funzioni di data e ora comuni di Hive e i loro 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, poiché questo valore è privo di 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 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 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	Utilizzalo 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 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

Funzioni definite dall'utente e UDAF

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 di 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 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-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 ogni giorno. Per utilizzare al meglio la tua 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 (incluso INSERT) utilizzando un'istruzione MERGE.

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

Istruzione UPDATE

La maggior parte delle istruzioni UPDATE di 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 maggiori 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 WHERE clausola.
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 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.

Istruzione ALTER

La seguente tabella fornisce i 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 e poi 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 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 ulteriori informazioni, consulta Formati e tipi di compressione dell'esportazione.
Table storage properties	ALTER TABLE table_name CLUSTERED BY (col_name, col_name, ...) [SORTED BY (col_name, ...)] INTO num_buckets BUCKETS;	Non supportata 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", ...] );	Lo spazio di archiviazione per il bilanciamento delle prestazioni 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 l'estratto conto 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. Se necessario, vengono aggiunte altre partizioni quando vengono caricati dati con nuovi valori nelle colonne di partizione. Per ulteriori informazioni, 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];	Sono supportati 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 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 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 seguente tabella fornisce i 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 in base alla data, rimuovi il commento da quanto segue: PARTITION BY dt OPTIONS( description="Table Description", Quando esegui il partizionamento per data, rimuovi il commento che segue. 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: Il formato LIKE di CREATE TABLE consente di copiare esattamente la definizione di una tabella esistente.	CREATE TABLE empty_key_value_store LIKE key_value_store [TBLPROPERTIES (property_name=property_value, ...)];	Non supportati.
Tabelle ordinate in bucket (raggruppate 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 saperne di più, consulta Creare e utilizzare tabelle in cluster.
Tabelle inclinate (tabelle in cui una o più colonne hanno valori inclinati)	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 la 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 all'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 la disposizione di scrittura per la tabella su WRITE_TRUNCATE se l'operazione di troncamento è un caso d'uso comune per la tabella specificata. Usa l'istruzione CREATE OR REPLACE TABLE. Usa 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 delle tabelle esterne in BigQuery, consulta Introduzione alle origini dati esterne.

Estratti conto CREATE VIEW e DROP VIEW

La seguente tabella fornisce i 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 seguente tabella 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'] ];	Opzione 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 supportati.

Estratti conto CREATE MACRO e DROP MACRO

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

Alveare	BigQuery
CREATE TEMPORARY MACRO macro_name([col_name col_type, ...]) expression;	Non supportati. In alcuni casi, 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 errori, elimina l'origine dell'errore, poiché BigQuery non restituisce gli stessi codici di errore.

In BigQuery, viene 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 attivate per impostazione predefinita in Hive 3.

Semantica dell'ACID

Hive supporta l'isolamento degli snapshot. Quando esegui una query, questa riceve uno snapshot coerente del database, che utilizza fino alla fine dell'esecuzione. Hive fornisce semantica ACID completa a livello di riga, consentendo a un'applicazione di aggiungere righe quando un'altra applicazione legge dalla stessa partizione senza interferire l'una con l'altra.

BigQuery offre un controllo ottimistico della contemporaneità (il primo a eseguire il commit delle vittorie) con isolamento snapshot, in cui una query legge gli ultimi dati di cui è stato eseguito il commit prima dell'avvio. 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 contemporaneità pessimistica. I job di caricamento possono essere eseguiti in modo indipendente e possono aggiungere tabelle. Tuttavia, BigQuery non fornisce una sessione o un confine di transazione espliciti.

Transazioni

Hive non supporta le transazioni con più istruzioni. Non supporta le istruzioni BEGIN, COMMIT e ROLLBACK. In Hive, viene eseguito il commit automatico di tutte le operazioni relative al linguaggio.

BigQuery supporta le transazioni a istruzioni multiple all'interno di una singola query o in più query quando usi le sessioni. Una transazione a più istruzioni consente di eseguire operazioni di modifica, 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 con più estratti conto.