Guía de traducción de SQL de Apache Hive

En este documento se detallan las similitudes y las diferencias entre las sintaxis SQL de Apache Hive y BigQuery para ayudarte a planificar tu migración. Para migrar tus secuencias de comandos SQL en bloque, usa la traducción de SQL por lotes. Para traducir consultas ad hoc, usa la traducción interactiva de SQL.

En algunos casos, no hay una asignación directa entre un elemento SQL de Hive y BigQuery. Sin embargo, en la mayoría de los casos, BigQuery ofrece un elemento alternativo a Hive para ayudarte a conseguir la misma funcionalidad, como se muestra en los ejemplos de este documento.

Este documento está dirigido a arquitectos empresariales, administradores de bases de datos, desarrolladores de aplicaciones y especialistas en seguridad informática. Se da por supuesto que conoces Hive.

Tipos de datos

Hive y BigQuery tienen sistemas de tipos de datos diferentes. En la mayoría de los casos, puedes asignar tipos de datos de Hive a tipos de datos de BigQuery, con algunas excepciones, como MAP y UNION. Hive admite más conversiones de tipo implícitas que BigQuery. Como resultado, el traductor de SQL por lotes inserta muchas conversiones explícitas.

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 pares clave-valor (campo REPEAT)
UNION	STRUCT con diferentes tipos
-	GEOGRAPHY
-	JSON

Sintaxis de consulta

En esta sección se abordan las diferencias en la sintaxis de las consultas entre Hive y BigQuery.

SELECT declaración

La mayoría de las instrucciones de Hive SELECT son compatibles con BigQuery. En la siguiente tabla se muestra una lista de diferencias menores:

Funda	Hive	BigQuery
Subconsulta	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 );
Filtrado de columnas	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 );
Desglosar una matriz	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;

Cláusula FROM

La cláusula FROM de una consulta muestra las referencias de las tablas de las que se seleccionan los datos. En Hive, las referencias de tabla posibles incluyen tablas, vistas y subconsultas. BigQuery también admite todas estas referencias de tabla.

Puedes hacer referencia a tablas de BigQuery en la cláusula FROM mediante lo siguiente:

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

BigQuery también admite referencias de tabla adicionales:

• Versiones históricas de la definición de la tabla y las filas mediante FOR SYSTEM_TIME AS OF
• Rutas de campo, o cualquier ruta que se resuelva en un campo de un tipo de datos (como un STRUCT)
• Matrices acopladas

Operadores de comparación

En la siguiente tabla se proporcionan detalles sobre la conversión de operadores de Hive a BigQuery:

Función u operador	Hive	BigQuery
- Menos unario * Multiplicación / División + Suma - Resta	Todos los tipos de números	Todos los tipos de números. Para evitar errores durante la operación de división, puedes usar SAFE_DIVIDE o IEEE_DIVIDE.
~ Negación bit a bit | O bit a bit & Y bit a bit ^ O exclusivo bit a bit	Tipo de datos booleano	Tipo de datos booleano.
Desplazamiento a la izquierda	shiftleft(TINYINT|SMALLINT|INT a, INT b) shiftleft(BIGINT a, INT b)	<< número entero o bytes A << B, donde B debe ser del mismo tipo que A
Desplazamiento a la derecha	shiftright(TINYINT|SMALLINT|INT a, INT b) shiftright(BIGINT a, INT b)	>> número entero o bytes A >> B, donde B debe ser del mismo tipo que A
Módulo (resto)	X % Y Todos los tipos de números	MOD(X, Y)
División de números enteros	A DIV B y A/B para obtener una precisión detallada	Todos los tipos de números. Nota: Para evitar errores durante la operación de división, puedes usar SAFE_DIVIDE o IEEE_DIVIDE.
Negación unaria	!, NOT	NOT
Tipos que admiten comparaciones de igualdad	Todos los tipos primitivos	Todos los tipos comparables y STRUCT.
	a <=> b	No es compatible. Traduce lo siguiente: (a = b AND b IS NOT NULL OR a IS NULL)
	a <> b	No es compatible. Traduce lo siguiente: NOT (a = b AND b IS NOT NULL OR a IS NULL)
Operadores relacionales ( =, ==, !=, <, >, >= )	Todos los tipos primitivos	Todos los tipos comparables.
Comparación de cadenas	RLIKE, REGEXP	Función integrada REGEXP_CONTAINS. Usa la sintaxis de expresiones regulares de BigQuery para las funciones de cadena en los patrones de expresiones regulares.
[NOT] LIKE, [NOT] BETWEEN, IS [NOT] NULL	A [NOT] BETWEEN B AND C, A IS [NOT] (TRUE|FALSE), A [NOT] LIKE B	Igual que Hive. Además, BigQuery también admite el operador IN.

Condiciones de JOIN

Tanto Hive como BigQuery admiten los siguientes tipos de combinaciones:

• [INNER] JOIN

• LEFT [OUTER] JOIN

• RIGHT [OUTER] JOIN

• FULL [OUTER] JOIN

• CROSS JOIN y la unión cruzada con comas implícita equivalente

Para obtener más información, consulta Operación de unión y Uniones de Hive.

Conversión de tipos y casting

En la siguiente tabla se ofrecen detalles sobre la conversión de funciones de Hive a BigQuery:

Función u operador	Hive	BigQuery
Conversión de tipos	Cuando una conversión falla, se devuelve `NULL`.	Tiene la misma sintaxis que Hive. Para obtener más información sobre las reglas de conversión de tipos de BigQuery, consulta Reglas de conversión. Si la emisión falla, verás un error. Para que se comporte igual que Hive, usa SAFE_CAST.
SAFE llamadas de funciones		Si añades el prefijo SAFE a las llamadas de función, la función devuelve NULL en lugar de informar de un error. Por ejemplo, SAFE.SUBSTR('foo', 0, -2) AS safe_output; devuelve NULL. Nota: Si quieres enviar contenido de forma segura y sin errores, usa SAFE_CAST.

Tipos de conversión implícita

Cuando migres a BigQuery, tendrás que convertir la mayoría de tus conversiones implícitas de Hive en conversiones explícitas de BigQuery, excepto los siguientes tipos de datos, que BigQuery convierte implícitamente.

Tipo de BigQuery	Tipo de BigQuery
INT64	FLOAT64, NUMERIC, BIGNUMERIC
BIGNUMERIC	FLOAT64
NUMERIC	BIGNUMERIC, FLOAT64

BigQuery también realiza conversiones implícitas de los siguientes literales:

Tipo de BigQuery	Tipo de BigQuery
STRING literal (por ejemplo, "2008-12-25")	DATE
STRING literal (por ejemplo, "2008-12-25 15:30:00")	TIMESTAMP
STRING literal (por ejemplo, "2008-12-25T07:30:00")	DATETIME
STRING literal (por ejemplo, "15:30:00")	TIME

Tipos de conversión explícita

Si quieres convertir tipos de datos de Hive que BigQuery no convierte implícitamente, usa la función CAST(expression AS type) de BigQuery.

Functions

En esta sección se describen las funciones habituales que se usan en Hive y BigQuery.

Funciones de agregación

En la siguiente tabla se muestran las asignaciones entre las funciones de agregación comunes de Hive, las funciones de agregación estadística y las funciones de agregación aproximada con sus equivalentes de 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 no admite el resto de los argumentos que define 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

Funciones analíticas

En la siguiente tabla se muestran las asignaciones entre las funciones analíticas comunes de Hive y sus equivalentes en 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	Se puede usar una función definida por el usuario (UDF).

Funciones de fecha y hora

En la siguiente tabla se muestran las asignaciones entre las funciones de fecha y hora de Hive habituales y sus equivalentes en 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 es el valor recomendado, ya que no tiene zona horaria y es sinónimo de CURRENT_TIMESTAMP \ CURRENT_TIMESTAMP en 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 ofrece las siguientes funciones adicionales de fecha y hora:

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

Funciones de cadena

En la siguiente tabla se muestran las asignaciones entre las funciones de cadena de Hive y sus equivalentes en 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 ofrece las siguientes funciones de cadena adicionales:

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

Funciones matemáticas

En la siguiente tabla se muestran las asignaciones entre las funciones matemáticas de Hive y sus equivalentes en 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	Úsalo 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 ofrece las siguientes funciones matemáticas adicionales:

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

Funciones lógicas y condicionales

En la siguiente tabla se muestran las asignaciones entre las funciones lógicas y condicionales de Hive y sus equivalentes en 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

UDF y UDAF

BigQuery admite FDU, pero no funciones de agregación definidas por el usuario (FADUs).

Sintaxis de DML

En esta sección se abordan las diferencias en la sintaxis del lenguaje de manipulación de datos (DML) entre Hive y BigQuery.

INSERT declaración

La mayoría de las instrucciones de Hive INSERT son compatibles con BigQuery. En la siguiente tabla se muestran las excepciones:

Hive	BigQuery
INSERT INTO TABLE tablename [PARTITION (partcol1[=val1], partcol2[=val2] ...)] VALUES values_row [, values_row ...]	INSERT INTO table (...) VALUES (...); Nota: En BigQuery, omitir los nombres de las columnas en la instrucción INSERT solo funciona si se incluyen los valores de todas las columnas de la tabla de destino en orden ascendente según sus posiciones ordinales.
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 no admite operaciones de inserción y sobrescritura. Esta sintaxis de Hive se puede migrar a las instrucciones TRUNCATE y INSERT.

BigQuery impone cuotas de DML que restringen el número de instrucciones DML que puedes ejecutar al día. Para sacar el máximo partido de tu cuota, puedes seguir estos enfoques:

• Combina varias filas en una sola instrucción INSERT, en lugar de una fila por cada operación INSERT.

• Combina varias instrucciones DML (incluida INSERT) mediante una instrucción MERGE.

• Usa CREATE TABLE ... AS SELECT para crear y rellenar tablas.

UPDATE declaración

La mayoría de las instrucciones de Hive UPDATE son compatibles con BigQuery. En la siguiente tabla se muestran las excepciones:

Hive	BigQuery
UPDATE tablename SET column = value [, column = value ...] [WHERE expression]	UPDATE table SET column = expression [,...] [FROM ...] WHERE TRUE Nota: Todas las instrucciones UPDATE de BigQuery requieren la palabra clave WHERE, seguida de una condición.

DELETE y TRUNCATE

Puedes usar las instrucciones DELETE o TRUNCATE para quitar filas de una tabla sin que afecte al esquema ni a los índices de la tabla.

En BigQuery, la instrucción DELETE debe tener una cláusula WHERE. Para obtener más información sobre DELETE en BigQuery, consulta los ejemplos de DELETE.

Hive	BigQuery
DELETE FROM tablename [WHERE expression]	DELETE FROM table_name WHERE TRUE Las instrucciones de BigQuery DELETE requieren una cláusula WHERE .
TRUNCATE [TABLE] table_name [PARTITION partition_spec];	TRUNCATE TABLE [[project_name.]dataset_name.]table_name

MERGE declaración

La instrucción MERGE puede combinar las operaciones INSERT, UPDATE y DELETE en una sola instrucción upsert y realizar las operaciones. La operación MERGE debe coincidir con una fila de origen como máximo por cada fila de destino.

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: Debes enumerar todas las columnas que quieras actualizar.

ALTER declaración

En la siguiente tabla se ofrecen detalles sobre la conversión de instrucciones CREATE VIEW de Hive a BigQuery:

Función	Hive	BigQuery
Rename table	ALTER TABLE table_name RENAME TO new_table_name;	No es compatible. Una solución alternativa es usar un trabajo de copia con el nombre que quieras para la tabla de destino y, a continuación, eliminar la tabla antigua. 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, ... )	El servicio BigQuery gestiona la serialización y deserialización, y el usuario no puede configurarlas. Para saber cómo permitir que BigQuery lea datos de archivos CSV, JSON, AVRO, PARQUET u ORC, consulta Crear tablas externas de Cloud Storage. Admite los formatos de exportación CSV, JSON, AVRO y PARQUET. Para obtener más información, consulta Formatos de exportación y tipos de compresión.
Table storage properties	ALTER TABLE table_name CLUSTERED BY (col_name, col_name, ...) [SORTED BY (col_name, ...)] INTO num_buckets BUCKETS;	No se admite en las declaraciones de 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", ...] );	El servicio BigQuery gestiona el equilibrio del almacenamiento para las consultas de rendimiento y no se puede configurar.
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; Para obtener más información, consulta la ALTER TABLE ADD PRIMARY KEYdeclaración.
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, ...)	No es compatible. Se añaden particiones adicionales según sea necesario cuando se cargan datos con nuevos valores en las columnas de partición. Para obtener más información, consulta Gestionar tablas con particiones.
Rename partition	ALTER TABLE table_name PARTITION partition_spec RENAME TO PARTITION partition_spec;	No es compatible.
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;	No es compatible.
Recover partition	MSCK [REPAIR] TABLE table_name [ADD/DROP/SYNC PARTITIONS];	No es compatible.
Drop partition	ALTER TABLE table_name DROP [IF EXISTS] PARTITION partition_spec[, PARTITION partition_spec, ...] [IGNORE PROTECTION] [PURGE];	Se admite con los siguientes métodos: bq rm 'mydataset.table_name$partition_id' DELETE from table_name$partition_id WHERE 1=1 Para obtener más información, consulta Eliminar una partición.
(Un)Archive partition	ALTER TABLE table_name ARCHIVE PARTITION partition_spec; ALTER TABLE table_name UNARCHIVE PARTITION partition_spec;	No es compatible.
Table and partition file format	ALTER TABLE table_name [PARTITION partition_spec] SET FILEFORMAT file_format;	No es compatible.
Table and partition location	ALTER TABLE table_name [PARTITION partition_spec] SET LOCATION "new location";	No es compatible.
Table and partition touch	ALTER TABLE table_name TOUCH [PARTITION partition_spec];	No es compatible.
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;	No es compatible.
Table and partition compact	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] COMPACT 'compaction_type'[AND WAIT] [WITH OVERWRITE TBLPROPERTIES ("property"="value" [, ...])];	No es compatible.
Table and artition concatenate	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] CONCATENATE;	No es compatible.
Table and partition columns	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] UPDATE COLUMNS;	No se admite en las declaraciones de 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];	No es compatible.

Sintaxis de DDL

En esta sección se abordan las diferencias en la sintaxis del lenguaje de definición de datos (DDL) entre Hive y BigQuery.

CREATE TABLE y DROP TABLE

En la siguiente tabla se ofrecen detalles sobre la conversión de instrucciones CREATE TABLE de Hive a BigQuery:

Tipo	Hive	BigQuery
Tablas gestionadas	create table table_name ( id int, dtDontQuery string, name string )	CREATE TABLE `myproject`.mydataset.table_name ( id INT64, dtDontQuery STRING, name STRING )
Tablas con particiones	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 Cuando particiones por fecha, descomenta lo siguiente: PARTITION BY dt OPTIONS( description="Table Description", Cuando particiones por fecha, descomenta lo siguiente. Se recomienda usar require_partition cuando la tabla esté particionada. 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 de CREATE TABLE te permite copiar exactamente una definición de tabla.	CREATE TABLE empty_key_value_store LIKE key_value_store [TBLPROPERTIES (property_name=property_value, ...)];	No es compatible.
Tablas ordenadas por segmentos (en BigQuery se denominan "en clúster")	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 )' Para obtener más información, consulta Crear y usar tablas agrupadas en clústeres.
Tablas sesgadas (tablas en las que una o varias columnas tienen valores sesgados)	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];	No es compatible.
Tablas temporales	CREATE TEMPORARY TABLE list_bucket_multiple ( col1 STRING, col2 int, col3 STRING);	Para ello, puedes usar el tiempo de vencimiento de la siguiente manera: 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")] )
Tablas transaccionales	CREATE TRANSACTIONAL TABLE transactional_table_test(key string, value string) PARTITIONED BY(ds string) STORED AS ORC;	Todas las modificaciones de tablas en BigQuery cumplen los requisitos de ACID (atomicidad, coherencia, aislamiento y durabilidad).
Eliminar tabla	DROP TABLE [IF EXISTS] table_name [PURGE];	{DROP TABLE | DROP TABLE IF EXISTS} table_name
Truncar tabla	TRUNCATE TABLE table_name [PARTITION partition_spec]; partition_spec: : (partition_column = partition_col_value, partition_column = partition_col_value, ...)	No es compatible. Estas son las soluciones alternativas disponibles: Elimina la tabla y vuelve a crearla con el mismo esquema. Define el valor WRITE_TRUNCATE para la propiedad write_disposition de la tabla si la operación de truncado es un caso práctico habitual para la tabla en cuestión. Usa la instrucción CREATE OR REPLACE TABLE. Usa la instrucción DELETE from table_name WHERE 1=1. Nota: También se pueden truncar particiones específicas. Para obtener más información, consulta Eliminar una partición.

CREATE EXTERNAL TABLE y DROP EXTERNAL TABLE

Para obtener información sobre la compatibilidad con tablas externas en BigQuery, consulta la introducción a fuentes de datos externas.

CREATE VIEW y DROP VIEW

En la siguiente tabla se ofrecen detalles sobre la conversión de instrucciones CREATE VIEW de 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

CREATE FUNCTION y DROP FUNCTION

En la siguiente tabla se ofrecen detalles sobre la conversión de procedimientos almacenados de 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;	No es compatible.
CREATE FUNCTION [db_name.]function_name AS class_name [USING JAR|FILE|ARCHIVE 'file_uri' [, JAR|FILE|ARCHIVE 'file_uri'] ];	Esta función alfa está disponible para los proyectos incluidos en la lista de permitidos. 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;	No es compatible.

CREATE MACRO y DROP MACRO

En la siguiente tabla se explica cómo convertir instrucciones de SQL de procedimiento usadas en la creación de macros de Hive a BigQuery con declaración y asignación de variables:

Hive	BigQuery
CREATE TEMPORARY MACRO macro_name([col_name col_type, ...]) expression;	No es compatible. En algunos casos, se puede sustituir por una función definida por el usuario.
DROP TEMPORARY MACRO [IF EXISTS] macro_name;	No es compatible.

Códigos y mensajes de error

Los códigos de error de Hive y los códigos de error de BigQuery son diferentes. Si la lógica de tu aplicación detecta errores, elimina la fuente del error, ya que BigQuery no devuelve los mismos códigos de error.

En BigQuery, es habitual usar las vistas INFORMATION_SCHEMA o el registro de auditoría para examinar los errores.

Garantías de coherencia y aislamiento de transacciones

Tanto Hive como BigQuery admiten transacciones con semántica ACID. Las transacciones están habilitadas de forma predeterminada en Hive 3.

Semántica ACID

Hive admite el aislamiento de captura. Cuando ejecutas una consulta, se le proporciona una vista general coherente de la base de datos, que utiliza hasta el final de su ejecución. Hive proporciona semántica ACID completa a nivel de fila, lo que permite que una aplicación añada filas cuando otra aplicación lee de la misma partición sin interferir entre sí.

BigQuery proporciona control de simultaneidad optimista (el primero en confirmar gana) con aislamiento de instantáneas, en el que una consulta lee los últimos datos confirmados antes de que empiece la consulta. Este enfoque garantiza el mismo nivel de coherencia para cada fila y mutación, así como entre las filas de la misma instrucción DML, al tiempo que evita los interbloqueos. Si se realizan varias actualizaciones de DML en la misma tabla, BigQuery cambia al control de concurrencia pesimista. Las tareas de carga se pueden ejecutar de forma independiente y añadir tablas. Sin embargo, BigQuery no proporciona un límite de transacción ni una sesión explícitos.

Transacciones

Hive no admite transacciones con varias instrucciones. No admite las instrucciones BEGIN, COMMIT y ROLLBACK. En Hive, todas las operaciones de lenguaje se confirman automáticamente.

BigQuery admite transacciones de varias instrucciones en una sola consulta o en varias consultas cuando se usan sesiones. Una transacción de varias instrucciones te permite realizar operaciones de mutación, como insertar o eliminar filas de una o varias tablas, y confirmar o deshacer los cambios. Para obtener más información, consulta el artículo sobre las transacciones con varias declaraciones.