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

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

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

El público previsto para este documento son arquitectos empresariales, administradores de bases de datos, desarrolladores de aplicaciones y especialistas en seguridad de TI. Se da por sentado que estás familiarizado con Hive.

Tipos de datos

Hive y BigQuery tienen sistemas de tipos de datos diferentes. En la mayoría de los casos, puedes asignar los tipos de datos en Hive a los tipos de datos de BigQuery, con algunas excepciones, como MAP y UNION. Hive admite una conversión de tipos más implícita que la de 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 valores clave (campo REPEAT)
UNION	STRUCT con diferentes tipos
-	GEOGRAPHY
-	JSON

Sintaxis de las consultas

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

Declaración SELECT

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

Caso	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 );
Escala un arreglo	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 en una consulta enumera las referencias de la tabla de las que se seleccionan los datos. En Hive, las referencias de tablas posibles incluyen tablas, vistas y subconsultas. BigQuery también admite todas estas referencias de tablas.

Puedes hacer referencia a las tablas de BigQuery en la cláusula FROM de la siguiente manera:

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

BigQuery también admite referencias de tablas adicionales:

• Versiones históricas de la definición y las filas de la tabla con FOR SYSTEM_TIME AS OF
• Rutas de campo, o cualquier ruta que se resuelva en un campo dentro de un tipo de datos (como una STRUCT).
• Arrays planos.

Operadores de comparación

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

Función u operador	Hive	BigQuery
- Unario menos * 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, considera usar SAFE_DIVIDE o IEEE_DIVIDE.
~ NOT a nivel de bits | OR a nivel de bits & AND a nivel de bits ^ XOR a nivel de bits	Tipo de datos booleanos	Tipo de datos booleanos.
Desplazamiento a la izquierda	shiftleft(TINYINT|SMALLINT|INT a, INT b) shiftleft(BIGINT a, INT b)	<< Número entero o bytes A << B, en el que 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, en el que 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, considera usar SAFE_DIVIDE o IEEE_DIVIDE.
Negación unaria	!, NOT	NOT
Tipos que admiten comparaciones de igualdad	Todos los tipos básicos	Todos los tipos comparables y STRUCT.
	a <=> b	No compatible. Traducir a: (a = b AND b IS NOT NULL OR a IS NULL)
	a <> b	No compatible. Traducir a: NOT (a = b AND b IS NOT NULL OR a IS NULL)
Operadores relacionales ( =, ==, !=, <, >, >= )	Todos los tipos básicos	Todos los tipos comparables.
Comparación de cadenas	RLIKE, REGEXP	Función integrada de REGEXP_CONTAINS. Usa la sintaxis de regex de BigQuery para las funciones de cadenas para los patrones de expresión 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

Hive y BigQuery admiten los siguientes tipos de uniones:

• [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 y transmisión de tipos

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

Función u operador	Hive	BigQuery
Conversión de tipos	Cuando falla una conversión, se muestra "NULL".	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 falla la conversión, verás un error. Para tener el mismo comportamiento que Hive, usa SAFE_CAST en su lugar.
Llamadas a la función SAFE		Si colocas un prefijo en las llamadas a la función con SAFE, la función muestra NULL en lugar de informar errores. Por ejemplo, SAFE.SUBSTR('foo', 0, -2) AS safe_output; muestra NULL. Nota: Cuando realices conversiones de forma segura sin errores, usa SAFE_CAST.

Tipos de conversiones implícitas

Cuando migras a BigQuery, debes convertir la mayoría de tus conversiones implícitas de Hive en conversiones explícitas de BigQuery, excepto para los siguientes tipos de datos, que BigQuery convierte de forma implícita.

Desde el tipo de BigQuery	Hasta tipo de BigQuery
INT64	FLOAT64, NUMERIC, BIGNUMERIC
BIGNUMERIC	FLOAT64
NUMERIC	BIGNUMERIC, FLOAT64

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

Desde el tipo de BigQuery	Hasta tipo de BigQuery
Literal de STRING (por ejemplo, "2008-12-25")	DATE
Literal de STRING (por ejemplo, "2008-12-25 15:30:00")	TIMESTAMP
Literal de STRING (por ejemplo, "2008-12-25T07:30:00")	DATETIME
Literal de STRING (por ejemplo, "15:30:00")	TIME

Tipos de conversiones explícitas

Si quieres convertir tipos de datos de Hive que BigQuery no convierte de forma implícita, usa la función CAST(expression AS type) de BigQuery o cualquiera de las funciones de conversión de DATE y TIMESTAMP.

Funciones

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

Funciones de agregación

En la siguiente tabla, se muestran las asignaciones entre las funciones comunes de agregación de Hive, de agregación estadística y 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 funciones analíticas comunes de Hive con sus equivalentes de 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 comunes de fecha y hora de Hive y sus equivalentes de 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	Se recomienda CURRENT_DATETIME, ya que este valor 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 string

En la siguiente tabla, se muestran las asignaciones entre las funciones de cadenas de Hive y sus equivalentes de 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 string 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 de 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 de 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 es compatible con UDF, pero no con funciones de agregación definidas por el usuario (UDAF).

Sintaxis de DML

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

Declaración INSERT

La mayoría de las declaraciones INSERT de Hive 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 columna en la declaración INSERT solo funciona si los valores de todas las columnas de la tabla de destino se incluyen 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 las operaciones de inserción y reemplazo. Esta sintaxis de Hive se puede migrar a las declaraciones TRUNCATE y INSERT.

BigQuery impone cuotas DML que restringen la cantidad de declaraciones DML que puedes ejecutar a diario. Para aprovechar al máximo tu cuota, considera los siguientes enfoques:

• Combina múltiples filas en una sola declaración INSERT, en lugar de una fila para cada operación INSERT.

• Combina múltiples declaraciones DML (incluida INSERT) mediante una declaración MERGE.

• Usa CREATE TABLE ... AS SELECT para crear y propagar tablas nuevas.

Declaración UPDATE

La mayoría de las declaraciones UPDATE de Hive 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 declaraciones UPDATE en BigQuery requieren una palabra clave WHERE, seguida de una condición.

Declaraciones DELETE y TRUNCATE

Puedes usar declaraciones DELETE o TRUNCATE para quitar filas de una tabla sin afectar el esquema ni los índices de dicha tabla.

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

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

Declaración MERGE

La declaración MERGE puede combinar operaciones INSERT, UPDATE y DELETE en una sola declaración de inserción y realizar las operaciones. La operación MERGE debe hacer coincidir como máximo una fila de origen con 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 se deben actualizar.

Declaración ALTER

En la siguiente tabla, se proporcionan detalles para convertir las declaraciones CREATE VIEW de Hive a BigQuery:

Función	Hive	BigQuery
Rename table	ALTER TABLE table_name RENAME TO new_table_name;	No compatible. Una solución alternativa es usar un trabajo de copia con el nombre que deseas como tabla de destino y, luego, borrar el anterior. 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 de BigQuery administra la serialización y deserialización, y el usuario no puede configurarla. Para aprender a permitir que BigQuery lea datos de archivos CSV, JSON, AVRO, ORC o PARQUET, consulta Crea tablas externas de Cloud Storage. Compatible con los formatos de exportación CSV, JSON, AVRO y PARQUET. Para obtener más información, consulta Exporta formatos 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 compatible con las declaraciones 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 de BigQuery administra el almacenamiento de balanceo de 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 declaración 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, ...)	No compatible. Se agregan particiones adicionales según sea necesario cuando se cargan datos con valores nuevos en las columnas de partición. Para obtener más información, consulta Administra tablas particionadas.
Rename partition	ALTER TABLE table_name PARTITION partition_spec RENAME TO PARTITION partition_spec;	No 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 compatible.
Recover partition	MSCK [REPAIR] TABLE table_name [ADD/DROP/SYNC PARTITIONS];	No compatible.
Drop partition	ALTER TABLE table_name DROP [IF EXISTS] PARTITION partition_spec[, PARTITION partition_spec, ...] [IGNORE PROTECTION] [PURGE];	Compatible 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 Borra una partición.
(Un)Archive partition	ALTER TABLE table_name ARCHIVE PARTITION partition_spec; ALTER TABLE table_name UNARCHIVE PARTITION partition_spec;	No compatible.
Table and partition file format	ALTER TABLE table_name [PARTITION partition_spec] SET FILEFORMAT file_format;	No compatible.
Table and partition location	ALTER TABLE table_name [PARTITION partition_spec] SET LOCATION "new location";	No compatible.
Table and partition touch	ALTER TABLE table_name TOUCH [PARTITION partition_spec];	No 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 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 compatible.
Table and artition concatenate	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] CONCATENATE;	No compatible.
Table and partition columns	ALTER TABLE table_name [PARTITION (partition_key = 'partition_value' [, ...])] UPDATE COLUMNS;	No compatible con las declaraciones 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 compatible.

Sintaxis del DDL

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

Declaraciones CREATE TABLE y DROP TABLE

En la siguiente tabla, se proporcionan detalles para convertir las declaraciones CREATE TABLE de Hive a BigQuery:

Tipo	Hive	BigQuery
Tablas administradas	create table table_name ( id int, dtDontQuery string, name string )	CREATE TABLE `myproject`.mydataset.table_name ( id INT64, dtDontQuery STRING, name STRING )
Tablas particionadas	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 realices particiones por fecha, quita los comentarios de lo siguiente: PARTITION BY dt OPTIONS( description="Table Description", Cuando realices particiones por fecha, quita los comentarios de 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: El formulario LIKE de CREATE TABLE te permite copiar una definición de tabla existente con exactitud.	CREATE TABLE empty_key_value_store LIKE key_value_store [TBLPROPERTIES (property_name=property_value, ...)];	No compatible.
Tablas ordenadas en clústeres (agrupadas en clústered de 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 )' Para obtener más información, consulta Crea y usa tablas agrupadas en clústeres.
Tablas sesgadas (tablas en las que una o más 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 compatible.
Tablas temporales	CREATE TEMPORARY TABLE list_bucket_multiple ( col1 STRING, col2 int, col3 STRING);	Puedes lograr esto con la fecha 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 la tabla en BigQuery cumplen con los criterios 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 compatible. Las siguientes soluciones alternativas están disponibles: Descarta y crea la tabla de nuevo con el mismo esquema. Establece la disposición de escritura en la tabla como WRITE_TRUNCATE si el procedimiento de truncamiento es un caso de uso común para la tabla determinada. Usa la declaración CREATE OR REPLACE TABLE. Usa la declaración DELETE from table_name WHERE 1=1. Nota: Las particiones específicas también se pueden truncar. Para obtener más información, consulta Borra una partición.

Declaraciones CREATE EXTERNAL TABLE y DROP EXTERNAL TABLE

Para obtener asistencia sobre tablas externas en BigQuery, consulta Introducción a las fuentes de datos externas.

Declaraciones CREATE VIEW y DROP VIEW

En la siguiente tabla, se proporcionan detalles para convertir las declaraciones 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

Declaraciones CREATE FUNCTION y DROP FUNCTION

En la siguiente tabla, se proporcionan 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 compatible.
CREATE FUNCTION [db_name.]function_name AS class_name [USING JAR|FILE|ARCHIVE 'file_uri' [, JAR|FILE|ARCHIVE 'file_uri'] ];	Compatible con proyectos incluidos en la lista de entidades permitidas como una función Alfa. 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 compatible.

Declaraciones CREATE MACRO y DROP MACRO

En la siguiente tabla, se proporcionan detalles sobre la conversión de instrucciones de SQL de procedimiento que se usan para crear una macro de Hive a BigQuery con declaración y asignación variables:

Hive	BigQuery
CREATE TEMPORARY MACRO macro_name([col_name col_type, ...]) expression;	No compatible. En algunos casos, se puede sustituir por una UDF.
DROP TEMPORARY MACRO [IF EXISTS] macro_name;	No compatible.

Mensajes y códigos de error

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

En BigQuery, es común usar las vistas INFORMATION_SCHEMA o el registro de auditoría para examinar errores.

Garantías de coherencia y aislamiento de transacción

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

Semántica de ACID

Hive admite el aislamiento de instantáneas. Cuando ejecutas una consulta, esta se proporciona con una instantánea coherente de la base de datos, que se usa hasta el final de su ejecución. Hive proporciona una semántica de ACID completa a nivel de fila, lo que permite que una aplicación agregue filas cuando otra aplicación lea desde la misma partición sin interferir entre sí.

BigQuery proporciona control de simultaneidad optimista (gana el primero en confirmarse) con el aislamiento de instantáneas, de modo que una consulta lea los últimos datos que se confirmaron antes de comenzar la consulta. Este enfoque garantiza el mismo nivel de coherencia para cada fila y mutación, y entre las filas dentro de la misma declaración DML, a la vez que evita los interbloqueos. Para varias actualizaciones de DML en la misma tabla, BigQuery cambia al control de simultaneidad pesimista. Los trabajos de carga pueden ejecutarse de forma independiente y agregar tablas. Sin embargo, BigQuery no proporciona un límite de transacción explícito ni una sesión.

Transacciones

Hive no admite transacciones de varias declaraciones. No es compatible con las declaraciones BEGIN, COMMIT ni ROLLBACK. En Hive, todas las operaciones de lenguaje se confirman de forma automática.

BigQuery admite transacciones de varias declaraciones dentro de una sola consulta o en varias consultas cuando se usan sesiones. Una transacción de varias declaraciones te permite realizar operaciones de mutación, como insertar o borrar filas en una o más tablas, y confirmar o revertir los cambios. Para obtener más información, consulta Transacciones de varias declaraciones.