Esta página se ha traducido con Cloud Translation API.

Guía de traducción de SQL de Teradata

En este documento se detallan las similitudes y las diferencias entre las sintaxis SQL de Teradata y BigQuery para ayudarte a planificar tu migración. Usa la traducción de SQL por lotes para migrar tus secuencias de comandos de SQL en bloque o la traducción de SQL interactiva para traducir consultas puntuales.

Tipos de datos

En esta sección se muestran las equivalencias entre los tipos de datos de Teradata y BigQuery.

Teradata	BigQuery	Notas
`INTEGER`	`INT64`
`SMALLINT`	`INT64`
`BYTEINT`	`INT64`
`BIGINT`	`INT64`
`DECIMAL`	`NUMERIC, DECIMAL` `BIGNUMERIC, BIGDECIMAL`	Usa `NUMERIC` (alias `DECIMAL`) de BigQuery cuando la escala (número de dígitos después del separador decimal) sea igual o inferior a 9. Usa `BIGNUMERIC` de BigQuery (alias `BIGDECIMAL`) cuando la escala sea superior a 9. Usa los tipos de datos decimales parametrizados de BigQuery si necesitas aplicar límites (restricciones) personalizados de dígitos o de escala. Teradata le permite insertar valores de mayor precisión redondeando el valor almacenado. Sin embargo, mantiene la alta precisión en los cálculos. Esto puede provocar un comportamiento de redondeo inesperado en comparación con el estándar ANSI.
`FLOAT`	`FLOAT64`
`NUMERIC`	`NUMERIC, DECIMAL` `BIGNUMERIC, BIGDECIMAL`	Usa `NUMERIC` (alias `DECIMAL`) de BigQuery cuando la escala (número de dígitos después del separador decimal) sea igual o inferior a 9. Usa `BIGNUMERIC` de BigQuery (alias `BIGDECIMAL`) cuando la escala sea superior a 9. Usa los tipos de datos decimales parametrizados de BigQuery si necesitas aplicar límites (restricciones) personalizados de dígitos o de escala. Teradata le permite insertar valores de mayor precisión redondeando el valor almacenado. Sin embargo, mantiene la alta precisión en los cálculos. Esto puede provocar un comportamiento de redondeo inesperado en comparación con el estándar ANSI.
`NUMBER`	`NUMERIC, DECIMAL` `BIGNUMERIC, BIGDECIMAL`	Usa `NUMERIC` (alias `DECIMAL`) de BigQuery cuando la escala (número de dígitos después del separador decimal) sea igual o inferior a 9. Usa `BIGNUMERIC` de BigQuery (alias `BIGDECIMAL`) cuando la escala sea superior a 9. Usa los tipos de datos decimales parametrizados de BigQuery si necesitas aplicar límites (restricciones) personalizados de dígitos o de escala. Teradata le permite insertar valores de mayor precisión redondeando el valor almacenado. Sin embargo, mantiene la alta precisión en los cálculos. Esto puede provocar un comportamiento de redondeo inesperado en comparación con el estándar ANSI.
`REAL`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	Usa el tipo de datos parametrizado `STRING` de BigQuery si necesitas aplicar una longitud máxima de caracteres.
`VARCHAR`	`STRING`	Usa el tipo de datos parametrizado `STRING` de BigQuery si necesitas aplicar una longitud máxima de caracteres.
`CLOB`	`STRING`
`JSON`	`JSON`
`BLOB`	`BYTES`
`BYTE`	`BYTES`
`VARBYTE`	`BYTES`
`DATE`	`DATE`	BigQuery no admite formatos personalizados similares a los que admite Teradata con DataForm en SDF.
`TIME`	`TIME`
`TIME WITH TIME ZONE`	`TIME`	Teradata almacena el tipo de datos `TIME` en UTC y te permite enviar un desfase desde UTC mediante la sintaxis `WITH TIME ZONE`. El tipo de datos `TIME` de BigQuery representa una hora independiente de cualquier fecha o zona horaria.
`TIMESTAMP`	`TIMESTAMP`	Tanto los tipos de datos de Teradata como los de BigQuery `TIMESTAMP` tienen una precisión de microsegundos (pero Teradata admite segundos bisiestos, mientras que BigQuery no). Los tipos de datos de Teradata y BigQuery suelen estar asociados a la zona horaria UTC (más información).
`TIMESTAMP WITH TIME ZONE`	`TIMESTAMP`	El `TIMESTAMP` de Teradata se puede definir en una zona horaria diferente en todo el sistema, por usuario o por columna (con `WITH TIME ZONE`). El tipo `TIMESTAMP` de BigQuery usa UTC si no especificas una zona horaria. Asegúrese de exportar la información de la zona horaria correctamente (no concatene un valor de `DATE` y `TIME` sin información de la zona horaria) para que BigQuery pueda convertirla al importarla. También puedes convertir la información de la zona horaria a UTC antes de exportarla. BigQuery tiene `DATETIME` para una abstracción entre la hora civil, que no muestra una zona horaria cuando se genera, y `TIMESTAMP`, que es un momento preciso que siempre muestra la zona horaria UTC.
`ARRAY`	`ARRAY`
`MULTI-DIMENSIONAL ARRAY`	`ARRAY`	En BigQuery, usa una matriz de structs, donde cada struct contiene un campo de tipo `ARRAY`. Para obtener más información, consulta la documentación de BigQuery.
`INTERVAL HOUR`	`INT64`
`INTERVAL MINUTE`	`INT64`
`INTERVAL SECOND`	`INT64`
`INTERVAL DAY`	`INT64`
`INTERVAL MONTH`	`INT64`
`INTERVAL YEAR`	`INT64`
`PERIOD(DATE)`	`DATE`, `DATE`	`PERIOD(DATE)` se debe convertir en dos columnas `DATE` que contengan la fecha de inicio y la fecha de finalización para que se puedan usar con funciones de ventana.
`PERIOD(TIMESTAMP WITH TIME ZONE)`	`TIMESTAMP`, `TIMESTAMP`
`PERIOD(TIMESTAMP)`	`TIMESTAMP`, `TIMESTAMP`
`PERIOD(TIME)`	`TIME`, `TIME`
`PERIOD(TIME WITH TIME ZONE)`	`TIME`, `TIME`
`UDT`	`STRING`
`XML`	`STRING`
`TD_ANYTYPE`	`STRING`

Para obtener más información sobre la conversión de tipos, consulta la siguiente sección.

Formato de tipo de Teradata

Teradata SQL usa un conjunto de formatos predeterminados para mostrar expresiones y datos de columnas, así como para las conversiones entre tipos de datos. Por ejemplo, el tipo de datos PERIOD(DATE) en el modo INTEGERDATE tiene el formato YY/MM/DD de forma predeterminada. Te recomendamos que uses el modo ANSIDATE siempre que sea posible para asegurarte de que cumples el estándar ANSI SQL y aproveches esta oportunidad para eliminar los formatos antiguos.

Teradata permite aplicar automáticamente formatos personalizados mediante la cláusula FORMAT sin cambiar el almacenamiento subyacente, ya sea como atributo de tipo de datos cuando se crea una tabla con DDL o en una expresión derivada. Por ejemplo, la especificación FORMAT 9.99 redondea cualquier valor de FLOAT a dos dígitos. En BigQuery, esta función se debe convertir con la función ROUND().

Esta función requiere gestionar casos límite complejos. Por ejemplo, cuando se aplica la cláusula FORMAT a una columna NUMERIC, debes tener en cuenta las reglas especiales de redondeo y formato. Se puede usar una cláusula FORMAT para convertir implícitamente un valor de época INTEGER a un formato DATE. O bien, una especificación FORMAT X(6) en una columna VARCHAR trunca el valor de la columna, por lo que debe convertirlo en una función SUBSTR(). Este comportamiento no cumple el estándar ANSI SQL. Por lo tanto, te recomendamos que no migres los formatos de columna a BigQuery.

Si es imprescindible usar formatos de columna, utilice Vistas o funciones definidas por el usuario (UDF).

Para obtener información sobre los formatos predeterminados que usa Teradata SQL para cada tipo de datos, consulta la documentación sobre el formato predeterminado de Teradata.

Formato de tipo de fecha y hora

En la siguiente tabla se resumen las diferencias entre los elementos de formato de marca de tiempo y fecha de Teradata SQL y GoogleSQL.

Formato de Teradata	Descripción de Teradata	BigQuery
`CURRENT_TIMESTAMP CURRENT_TIME`	La información de `TIME` y `TIMESTAMP` en Teradata puede tener información de zona horaria diferente, que se define mediante `WITH TIME ZONE`.	Si es posible, usa `CURRENT_TIMESTAMP()`, que tiene el formato ISO. Sin embargo, el formato de salida siempre muestra la zona horaria UTC. Internamente, BigQuery no tiene una zona horaria. Tenga en cuenta los siguientes detalles sobre las diferencias en el formato ISO. `DATETIME` se formatea según las convenciones del canal de salida. En la herramienta de línea de comandos de BigQuery y en la consola de BigQuery, se da formato con un separador `T` según el RFC 3339. Sin embargo, en Python y Java JDBC, se usa un espacio como separador. Si quieres usar un formato explícito, usa `FORMAT_DATETIME()`, que convierte explícitamente un valor en una cadena. Por ejemplo, la siguiente expresión siempre devuelve un separador de espacio: `CAST(CURRENT_DATETIME() AS STRING)` Teradata admite la palabra clave `DEFAULT` en las columnas `TIME` para definir la hora actual (marca de tiempo). Esta palabra clave no se usa en BigQuery.
`CURRENT_DATE`	Las fechas se almacenan en Teradata como valores `INT64` mediante la siguiente fórmula: `(YEAR - 1900) * 10000 + (MONTH * 100) + DAY` Las fechas se pueden formatear como números enteros.	BigQuery tiene un formato `DATE` independiente que siempre devuelve una fecha en formato ISO 8601. No se puede usar `DATE_FROM_UNIX_DATE` porque se basa en 1970. Teradata admite la palabra clave `DEFAULT` en las columnas `DATE` para definir la fecha actual. BigQuery no usa esta palabra clave.
`CURRENT_DATE-3`	Los valores de fecha se representan como números enteros. Teradata admite operadores aritméticos para tipos de fecha.	En el caso de los tipos de fecha, usa `DATE_ADD()` o `DATE_SUB()`. BigQuery usa operadores aritméticos para los tipos de datos: `INT64`, `NUMERIC` y `FLOAT64`.
`SYS_CALENDAR.CALENDAR`	Teradata proporciona una vista para las operaciones de calendario que va más allá de las operaciones con números enteros.	No se usa en BigQuery.
`SET SESSION DATEFORM=ANSIDATE`	Define el formato de fecha de la sesión o del sistema como ANSI (ISO 8601).	BigQuery siempre usa el formato ISO 8601, así que asegúrate de convertir las fechas y horas de Teradata.

Sintaxis de consulta

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

`SELECT` declaración

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

Teradata		BigQuery
`SEL`		Convertir a `SELECT`. BigQuery no usa la abreviatura `SEL`.
`SELECT (subquery) AS flag, CASE WHEN flag = 1 THEN ...`		En BigQuery, las columnas no pueden hacer referencia a la salida de otras columnas definidas en la misma lista de selección. Prefiere mover una subconsulta a una cláusula `WITH`. `WITH flags AS ( subquery ), SELECT CASE WHEN flags.flag = 1 THEN ...`
`SELECT * FROM table WHERE A LIKE ANY ('string1', 'string2')`		BigQuery no usa el predicado lógico `ANY`. Se puede conseguir la misma función usando varios operadores `OR`: `SELECT * FROM table WHERE col LIKE 'string1' OR col LIKE 'string2'` En este caso, la comparación de cadenas también es diferente. Consulta Operadores de comparación.
`SELECT TOP 10 * FROM table`		BigQuery usa `LIMIT` al final de una consulta en lugar de `TOP n` después de la palabra clave `SELECT`.

Operadores de comparación

En la siguiente tabla se muestran los operadores de comparación de Teradata que son específicos de Teradata y que deben convertirse en los operadores compatibles con ANSI SQL:2011 que se usan en BigQuery.

Para obtener información sobre los operadores de BigQuery, consulta la sección Operadores de la documentación de BigQuery.

Teradata	BigQuery	Notas
`exp EQ exp2` `exp IN (exp2, exp3)`	`exp = exp2` `exp IN (exp2, exp3)` Para mantener la semántica no ANSI de `NOT CASESPECIFIC`, puedes usar `RTRIM(UPPER(exp)) = RTRIM(UPPER(exp2))`	Al comparar cadenas para comprobar si son iguales, Teradata puede ignorar los espacios en blanco finales, mientras que BigQuery los considera parte de la cadena. Por ejemplo, `'xyz'=' xyz'` es `TRUE` en Teradata, pero `FALSE` en BigQuery. Teradata también proporciona un atributo de columna `NOT CASESPECIFIC` que indica a Teradata que ignore las mayúsculas y minúsculas al comparar dos cadenas. BigQuery siempre distingue entre mayúsculas y minúsculas al comparar cadenas. Por ejemplo, `'xYz' = 'xyz'` es `TRUE` en Teradata, pero `FALSE` en BigQuery.
`exp LE exp2`	`exp <= exp2`
`exp LT exp2`	`exp < exp2`
`exp NE exp2`	`exp <> exp2 exp != exp2`
`exp GE exp2`	`exp >= exp2`
`exp GT exp2`	`exp > exp2`

`JOIN` condiciones

BigQuery y Teradata admiten las mismas condiciones JOIN, ON y USING. En la siguiente tabla se incluye una lista de diferencias menores.

Teradata	BigQuery	Notas
`FROM A JOIN B ON A.date > B.start_date AND A.date < B.end_date`	`FROM A LEFT OUTER JOIN B ON A.date > B.start_date AND A.date < B.end_date`	BigQuery admite cláusulas `JOIN` de desigualdad en todas las combinaciones internas o si se da al menos una condición de igualdad (=). Sin embargo, no admite solo una condición de desigualdad (= y <) en una `OUTER JOIN`. Estas estructuras se usan a veces para consultar intervalos de fechas o de números enteros. BigQuery impide que los usuarios creen grandes combinaciones cruzadas por error.
`FROM A, B ON A.id = B.id`	`FROM A JOIN B ON A.id = B.id`	Usar una coma entre tablas en Teradata equivale a `INNER JOIN`, mientras que en BigQuery equivale a `CROSS JOIN` (producto cartesiano). Como la coma en el SQL antiguo de BigQuery se trata como `UNION`, te recomendamos que hagas la operación de forma explícita para evitar confusiones.
`FROM A JOIN B ON (COALESCE(A.id , 0) = COALESCE(B.id, 0))`	`FROM A JOIN B ON (COALESCE(A.id , 0) = COALESCE(B.id, 0))`	No hay ninguna diferencia en las funciones escalares (constantes).
`FROM A JOIN B ON A.id = (SELECT MAX(B.id) FROM B)`	`FROM A JOIN (SELECT MAX(B.id) FROM B) B1 ON A.id = B1.id`	BigQuery impide que los usuarios utilicen subconsultas, subconsultas correlacionadas o agregaciones en predicados de unión. Esto permite que BigQuery paralelice las consultas.

Conversión de tipos y casting

BigQuery tiene menos tipos de datos que Teradata, pero son más amplios, por lo que BigQuery debe ser más estricto a la hora de convertir tipos.

Teradata	BigQuery	Notas
`exp EQ exp2` `exp IN (exp2, exp3)`	`exp = exp2` `exp IN (exp2, exp3)` Para mantener la semántica no ANSI de `NOT CASESPECIFIC`, puedes usar `RTRIM(UPPER(exp)) = RTRIM(UPPER(exp2))`	Al comparar cadenas para comprobar si son iguales, Teradata puede ignorar los espacios en blanco finales, mientras que BigQuery los considera parte de la cadena. Por ejemplo, `'xyz'=' xyz'` es `TRUE` en Teradata, pero `FALSE` en BigQuery. Teradata también proporciona un atributo de columna `NOT CASESPECIFIC` que indica a Teradata que ignore las mayúsculas y minúsculas al comparar dos cadenas. BigQuery siempre distingue entre mayúsculas y minúsculas al comparar cadenas. Por ejemplo, `'xYz' = 'xyz'` es `TRUE` en Teradata, pero `FALSE` en BigQuery.
`CAST(long_varchar_column AS CHAR(6))`	`LPAD(long_varchar_column, 6)`	A veces, la conversión de una columna de caracteres en Teradata se usa como una forma no estándar y no óptima de crear una subcadena con relleno.
`CAST(92617 AS TIME) 92617 (FORMAT '99:99:99')`	`PARSE_TIME("%k%M%S", CAST(92617 AS STRING))`	Teradata realiza muchas conversiones de tipos implícitas y redondeos más que BigQuery, que suele ser más estricto y aplica los estándares ANSI. (Este ejemplo devuelve 09:26:17)
`CAST(48.5 (FORMAT 'zz') AS FLOAT)`	`CAST(SUBSTR(CAST(48.5 AS STRING), 0, 2) AS FLOAT64)`	Los tipos de datos numéricos y de coma flotante pueden requerir reglas de redondeo especiales cuando se aplican con formatos como las monedas. (En este ejemplo, se devuelve 48)

Enviar `FLOAT`/`DECIMAL` a `INT`

Mientras que Teradata usa los algoritmos Gaussian y Banker para redondear números, BigQuery usa ROUND_HALF_EVEN RoundingMode:

round(CAST(2.5 as Numeric),0, 'ROUND_HALF_EVEN')

Enviar `STRING` a `NUMERIC` o `BIGNUMERIC`

Cuando convierta valores de STRING a numéricos, utilice el tipo de datos correcto, NUMERIC o BIGNUMERIC, en función del número de decimales del valor STRING.

Para obtener más información sobre la precisión y la escala numéricas admitidas en BigQuery, consulta Tipos decimales.

Consulte también los operadores de comparación y los formatos de columna. Tanto las comparaciones como el formato de las columnas pueden comportarse como conversiones de tipo.

`QUALIFY`, `ROWS` cláusulas

La cláusula QUALIFY de Teradata te permite filtrar los resultados de las funciones de ventana. También puedes usar una ROWSfrase para hacer lo mismo. Funcionan de forma similar a una condición HAVING para una cláusula GROUP, lo que limita el resultado de lo que en BigQuery se denomina funciones de ventana.

Teradata	BigQuery
`SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1;`	La cláusula `QUALIFY` de Teradata con una función de ventana como `ROW_NUMBER()`, `SUM()`, `COUNT()` y con `OVER PARTITION BY` se expresa en BigQuery como una cláusula `WHERE` en una subconsulta que contiene un valor analítico. Usar `ROW_NUMBER()`: `SELECT col1, col2 FROM ( SELECT col1, col2, ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) RN FROM table ) WHERE RN = 1;` Usar `ARRAY_AGG`, que admite particiones más grandes: `SELECT result.* FROM ( SELECT ARRAY_AGG(table ORDER BY table.col2 DESC LIMIT 1)[OFFSET(0)] FROM table GROUP BY col1 ) AS result;`
`SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 ROWS BETWEEN 2 PRECEDING AND CURRENT ROW);`	`SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 RANGE BETWEEN 2 PRECEDING AND CURRENT ROW);` En BigQuery, se pueden usar tanto `RANGE` como `ROWS` en la cláusula de marco de ventana. Sin embargo, las cláusulas de ventana solo se pueden usar con funciones de ventana como `AVG()`, no con funciones de numeración como `ROW_NUMBER()`.
`SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1;`	`SELECT col1, col2 FROM Dataset-name.table QUALIFY row_number() OVER (PARTITION BY upper(a.col1) ORDER BY upper(a.col2)) = 1`

`NORMALIZE` palabra clave

Teradata proporciona la palabra clave NORMALIZE para las cláusulas SELECT con el fin de fusionar periodos o intervalos superpuestos en un solo periodo o intervalo que abarque todos los valores de los periodos individuales.

BigQuery no admite el tipo PERIOD, por lo que cualquier columna de tipo PERIOD de Teradata se debe insertar en BigQuery como dos campos DATE o DATETIME independientes que correspondan al inicio y al final del periodo.

Teradata BigQuery

SELECT NORMALIZE client_id, item_sid, BEGIN(period) AS min_date, END(period) AS max_date, FROM table; SELECT t.client_id, t.item_sid, t.min_date, MAX(t.dwh_valid_to) AS max_date FROM ( SELECT d1.client_id, d1.item_sid, d1.dwh_valid_to AS dwh_valid_to, MIN(d2.dwh_valid_from) AS min_date FROM table d1 LEFT JOIN table d2 ON d1.client_id = d2.client_id AND d1.item_sid = d2.item_sid AND d1.dwh_valid_to >= d2.dwh_valid_from AND d1.dwh_valid_from < = d2.dwh_valid_to GROUP BY d1.client_id, d1.item_sid, d1.dwh_valid_to ) t GROUP BY t.client_id, t.item_sid, t.min_date;

Teradata	BigQuery
`SELECT NORMALIZE client_id, item_sid, BEGIN(period) AS min_date, END(period) AS max_date, FROM table;`	SELECT t.client_id, t.item_sid, t.min_date, MAX(t.dwh_valid_to) AS max_date FROM ( SELECT d1.client_id, d1.item_sid, d1.dwh_valid_to AS dwh_valid_to, MIN(d2.dwh_valid_from) AS min_date FROM table d1 LEFT JOIN table d2 ON d1.client_id = d2.client_id AND d1.item_sid = d2.item_sid AND d1.dwh_valid_to >= d2.dwh_valid_from AND d1.dwh_valid_from < = d2.dwh_valid_to GROUP BY d1.client_id, d1.item_sid, d1.dwh_valid_to ) t GROUP BY t.client_id, t.item_sid, t.min_date;

Functions

En las siguientes secciones se enumeran las asignaciones entre las funciones de Teradata y sus equivalentes en BigQuery.

Funciones de agregación

En la siguiente tabla se asignan las funciones de agregación, agregación estadística y agregación aproximada de Teradata a sus equivalentes en BigQuery. BigQuery ofrece las siguientes funciones de agregación adicionales:

Teradata	BigQuery
`AVG`	`AVG` Nota: BigQuery proporciona resultados aproximados al calcular la media de `INT` valores.
`BITAND`	`BIT_AND`
`BITNOT`	Operador NOT a nivel de bits (`~`)
`BITOR`	`BIT_OR`
`BITXOR`	`BIT_XOR`
`CORR`	`CORR`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`MAX`	`MAX`
`MIN`	`MIN`
`REGR_AVGX`	`AVG( IF(dep_var_expression is NULL OR ind_var_expression is NULL, NULL, ind_var_expression) )`
`REGR_AVGY`	`AVG( IF(dep_var_expression is NULL OR ind_var_expression is NULL, NULL, dep_var_expression) )`
`REGR_COUNT`	`SUM( IF(dep_var_expression is NULL OR ind_var_expression is NULL, NULL, 1) )`
`REGR_INTERCEPT`	`AVG(dep_var_expression) - AVG(ind_var_expression) * (COVAR_SAMP(ind_var_expression, dep_var_expression) / VARIANCE(ind_var_expression))`
`REGR_R2`	`(COUNT(dep_var_expression)* SUM(ind_var_expression * dep_var_expression) - SUM(dep_var_expression) * SUM(ind_var_expression)) / SQRT( (COUNT(ind_var_expression)* SUM(POWER(ind_var_expression, 2))* POWER(SUM(ind_var_expression),2))* (COUNT(dep_var_expression)* SUM(POWER(dep_var_expression, 2))* POWER(SUM(dep_var_expression), 2)))`
`REGR_SLOPE`	`- COVAR_SAMP(ind_var_expression, dep_var_expression) / VARIANCE(ind_var_expression)`
`REGR_SXX`	`SUM(POWER(ind_var_expression, 2)) - COUNT(ind_var_expression) * POWER(AVG(ind_var_expression),2)`
`REGR_SXY`	`SUM(ind_var_expression * dep_var_expression) - COUNT(ind_var_expression) * AVG(ind_var_expression) * AVG(dep_var_expression)`
`REGR_SYY`	`SUM(POWER(dep_var_expression, 2)) - COUNT(dep_var_expression) * POWER(AVG(dep_var_expression),2)`
`SKEW`	Función personalizada definida por el usuario.
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`

Funciones analíticas y funciones de ventana

En la siguiente tabla se muestran las funciones analíticas y de agregación analíticas de Teradata más habituales y sus equivalentes en forma de funciones de ventana de BigQuery. BigQuery ofrece las siguientes funciones adicionales:

Teradata	BigQuery
`ARRAY_AGG`	`ARRAY_AGG`
`ARRAY_CONCAT, (\|\| operator)`	`ARRAY_CONCAT_AGG, (\|\| operator)`
`BITAND`	`BIT_AND`
`BITNOT`	Operador NOT a nivel de bits (`~`)
`BITOR`	`BIT_OR`
`BITXOR`	`BIT_XOR`
`CORR`	`CORR`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`CUME_DIST`	`CUME_DIST`
`DENSE_RANK` (ANSI)	`DENSE_RANK`
`FIRST_VALUE`	`FIRST_VALUE`
`LAST_VALUE`	`LAST_VALUE`
`MAX`	`MAX`
`MIN`	`MIN`
`PERCENT_RANK`	`PERCENT_RANK`
`PERCENTILE_CONT`, `PERCENTILE_DISC`	`PERCENTILE_CONT`, `PERCENTILE_DISC`
`QUANTILE`	`NTILE`
`RANK` (ANSI)	`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`

Funciones de fecha y hora

En la siguiente tabla se asignan funciones de fecha y hora comunes de Teradata a sus equivalentes de BigQuery. BigQuery ofrece las siguientes funciones de fecha y hora adicionales:

Teradata	BigQuery
`ADD_MONTHS`	`DATE_ADD, TIMESTAMP_ADD`
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_TIME`	`CURRENT_TIME`
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`
`DATE + k`	`DATE_ADD(date_expression, INTERVAL k DAY)`
`DATE - k`	`DATE_SUB(date_expression, INTERVAL k DAY)`
`EXTRACT`	`EXTRACT(DATE), EXTRACT(TIMESTAMP)`
	`FORMAT_DATE`
	`FORMAT_DATETIME`
	`FORMAT_TIME`
	`FORMAT_TIMESTAMP`
`LAST_DAY`	`LAST_DAY` Nota: Esta función admite expresiones de entrada `DATE` y `DATETIME`.
`MONTHS_BETWEEN`	`DATE_DIFF(date_expression, date_expression, MONTH)`
`NEXT_DAY`	`DATE_ADD( DATE_TRUNC( date_expression, WEEK(day_value) ), INTERVAL 1 WEEK )`
`OADD_MONTHS`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL num_months MONTH ), MONTH ), INTERVAL 1 DAY )`
`td_day_of_month`	`EXTRACT(DAY FROM date_expression) EXTRACT(DAY FROM timestamp_expression)`
`td_day_of_week`	`EXTRACT(DAYOFWEEK FROM date_expression) EXTRACT(DAYOFWEEK FROM timestamp_expression)`
`td_day_of_year`	`EXTRACT(DAYOFYEAR FROM date_expression) EXTRACT(DAYOFYEAR FROM timestamp_expression)`
`td_friday`	`DATE_TRUNC( date_expression, WEEK(FRIDAY) )`
`td_monday`	`DATE_TRUNC( date_expression, WEEK(MONDAY) )`
`td_month_begin`	`DATE_TRUNC(date_expression, MONTH)`
`td_month_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 MONTH ), MONTH ), INTERVAL 1 DAY )`
`td_month_of_calendar`	`(EXTRACT(YEAR FROM date_expression) - 1900) * 12 + EXTRACT(MONTH FROM date_expression)`
`td_month_of_quarter`	`EXTRACT(MONTH FROM date_expression) - ((EXTRACT(QUARTER FROM date_expression) - 1) * 3)`
`td_month_of_year`	`EXTRACT(MONTH FROM date_expression) EXTRACT(MONTH FROM timestamp_expression)`
`td_quarter_begin`	`DATE_TRUNC(date_expression, QUARTER)`
`td_quarter_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 QUARTER ), QUARTER ), INTERVAL 1 DAY )`
`td_quarter_of_calendar`	`(EXTRACT(YEAR FROM date_expression) - 1900) * 4 + EXTRACT(QUARTER FROM date_expression)`
`td_quarter_of_year`	`EXTRACT(QUARTER FROM date_expression) EXTRACT(QUARTER FROM timestamp_expression)`
`td_saturday`	`DATE_TRUNC( date_expression, WEEK(SATURDAY) )`
`td_sunday`	`DATE_TRUNC( date_expression, WEEK(SUNDAY) )`
`td_thursday`	`DATE_TRUNC( date_expression, WEEK(THURSDAY) )`
`td_tuesday`	`DATE_TRUNC( date_expression, WEEK(TUESDAY) )`
`td_wednesday`	`DATE_TRUNC( date_expression, WEEK(WEDNESDAY) )`
`td_week_begin`	`DATE_TRUNC(date_expression, WEEK)`
`td_week_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 WEEK ), WEEK ), INTERVAL 1 DAY )`
`td_week_of_calendar`	`(EXTRACT(YEAR FROM date_expression) - 1900) * 52 + EXTRACT(WEEK FROM date_expression)`
`td_week_of_month`	`EXTRACT(WEEK FROM date_expression) - EXTRACT(WEEK FROM DATE_TRUNC(date_expression, MONTH))`
`td_week_of_year`	`EXTRACT(WEEK FROM date_expression) EXTRACT(WEEK FROM timestamp_expression)`
`td_weekday_of_month`	`CAST( CEIL( EXTRACT(DAY FROM date_expression) / 7 ) AS INT64 )`
`td_year_begin`	`DATE_TRUNC(date_expression, YEAR)`
`td_year_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 YEAR ), YEAR ), INTERVAL 1 DAY )`
`td_year_of_calendar`	`EXTRACT(YEAR FROM date_expression)`
`TO_DATE`	`PARSE_DATE`
`TO_TIMESTAMP`	`PARSE_TIMESTAMP`
`TO_TIMESTAMP_TZ`	`PARSE_TIMESTAMP`

Funciones de cadena

En la siguiente tabla se asignan las funciones de cadena de Teradata a sus equivalentes de BigQuery. BigQuery ofrece las siguientes funciones de cadena adicionales:

Teradata	BigQuery
`ASCII`	`TO_CODE_POINTS(string_expression)[OFFSET(0)]`
`CHAR2HEXINT`	`TO_HEX`
`CHARACTER LENGTH`	`CHAR_LENGTH`
`CHARACTER LENGTH`	`CHARACTER_LENGTH`
`CHR`	`CODE_POINTS_TO_STRING( [mod(numeric_expression, 256)] )`
`CONCAT, (\|\| operator)`	`CONCAT, (\|\| operator)`
`CSV`	Función personalizada definida por el usuario.
`CSVLD`	Función personalizada definida por el usuario.
`FORMAT`	`FORMAT`
`INDEX`	`STRPOS(string, substring)`
`INITCAP`	`INITCAP`
`INSTR`	Función personalizada definida por el usuario.
`LEFT`	`SUBSTR(source_string, 1, length)`
`LENGTH`	`LENGTH`
`LOWER`	`LOWER`
`LPAD`	`LPAD`
`LTRIM`	`LTRIM`
`NGRAM`	Función personalizada definida por el usuario.
`NVP`	Función personalizada definida por el usuario.
`OREPLACE`	`REPLACE`
`OTRANSLATE`	Función personalizada definida por el usuario.
`POSITION`	`STRPOS(string, substring)`
`REGEXP_INSTR`	`STRPOS(source_string, REGEXP_EXTRACT(source_string, regexp_string))` Nota: Devuelve la primera coincidencia.
`REGEXP_REPLACE`	`REGEXP_REPLACE`
`REGEXP_SIMILAR`	`IF(REGEXP_CONTAINS,1,0)`
`REGEXP_SUBSTR`	`REGEXP_EXTRACT, REGEXP_EXTRACT_ALL`
`REGEXP_SPLIT_TO_TABLE`	Función personalizada definida por el usuario.
`REVERSE`	`REVERSE`
`RIGHT`	`SUBSTR(source_string, -1, length)`
`RPAD`	`RPAD`
`RTRIM`	`RTRIM`
`STRTOK` Nota: Cada carácter del argumento de cadena de delimitador se considera un carácter de delimitador independiente. El delimitador predeterminado es un espacio.	`SPLIT(instring, delimiter)[ORDINAL(tokennum)]` Nota: El argumento de cadena delimiter completo se usa como un único delimitador. El delimitador predeterminado es la coma.
`STRTOK_SPLIT_TO_TABLE`	Función personalizada definida por el usuario
`SUBSTRING`, `SUBSTR`	`SUBSTR`
`TRIM`	`TRIM`
`UPPER`	`UPPER`

Funciones matemáticas

En la siguiente tabla se asignan las funciones matemáticas de Teradata a sus equivalentes de BigQuery. BigQuery ofrece las siguientes funciones matemáticas adicionales:

Teradata	BigQuery
`ABS`	`ABS`
`ACOS`	`ACOS`
`ACOSH`	`ACOSH`
`ASIN`	`ASIN`
`ASINH`	`ASINH`
`ATAN`	`ATAN`
`ATAN2`	`ATAN2`
`ATANH`	`ATANH`
`CEILING`	`CEIL`
`CEILING`	`CEILING`
`COS`	`COS`
`COSH`	`COSH`
`EXP`	`EXP`
`FLOOR`	`FLOOR`
`GREATEST`	`GREATEST`
`LEAST`	`LEAST`
`LN`	`LN`
`LOG`	`LOG`
`MOD` (operador `%`)	`MOD`
`NULLIFZERO`	`NULLIF(expression, 0)`
`POWER` (operador `**`)	`POWER, POW`
`RANDOM`	`RAND`
`ROUND`	`ROUND`
`SIGN`	`SIGN`
`SIN`	`SIN`
`SINH`	`SINH`
`SQRT`	`SQRT`
`TAN`	`TAN`
`TANH`	`TANH`
`TRUNC`	`TRUNC`
`ZEROIFNULL`	`IFNULL(expression, 0), COALESCE(expression, 0)`

Funciones de redondeo

Mientras que Teradata usa los algoritmos Gaussian y Banker para redondear números, BigQuery usa ROUND_HALF_EVEN RoundingMode:


-- Teradata syntax
round(3.45,1)

-- BigQuery syntax
round(CAST(3.45 as Numeric),1, 'ROUND_HALF_EVEN')

Sintaxis de DML

En esta sección se abordan las diferencias en la sintaxis del lenguaje de gestión de datos entre Teradata y BigQuery.

`INSERT` declaración

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

Los scripts de DML de BigQuery tienen una semántica de coherencia ligeramente diferente a las instrucciones equivalentes de Teradata. Para obtener una descripción general del aislamiento de instantáneas y la gestión de sesiones y transacciones, consulta la sección CREATE INDEX de este documento.

Teradata BigQuery

INSERT INTO table VALUES (...); INSERT INTO table (...) VALUES (...);

Teradata ofrece la palabra clave DEFAULT para las columnas que no admiten valores nulos.

Nota: En BigQuery, omitir los nombres de las columnas en la declaració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.

Teradata	BigQuery
`INSERT INTO table VALUES (...);`	`INSERT INTO table (...) VALUES (...);` Teradata ofrece la palabra clave `DEFAULT` para las columnas que no admiten valores nulos. Nota: En BigQuery, omitir los nombres de las columnas en la declaració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 INTO table VALUES (1,2,3); INSERT INTO table VALUES (4,5,6); INSERT INTO table VALUES (7,8,9);`	`INSERT INTO table VALUES (1,2,3), (4,5,6), (7,8,9);` Teradata tiene el concepto de solicitud de varias instrucciones (MSR), que envía varias instrucciones `INSERT` a la vez. En BigQuery, no se recomienda debido al límite de transacción implícito entre las instrucciones. En su lugar, usa varios valores `INSERT`. BigQuery permite instrucciones `INSERT` simultáneas, pero puede ponerlas en cola`UPDATE`. Para mejorar el rendimiento, puede hacer lo siguiente: Combina varias filas en una sola instrucción `INSERT`, en lugar de una fila por operación `INSERT`. Combina varias instrucciones de DML (incluida `INSERT`) mediante una instrucción `MERGE`. Usa `CREATE TABLE ... AS SELECT` para crear y rellenar tablas en lugar de `UPDATE` o `DELETE`, sobre todo cuando hagas consultas en campos particionados o restauraciones o reversiones.


INSERT INTO table VALUES (1,2,3);

INSERT INTO table VALUES (4,5,6);

INSERT INTO table VALUES (7,8,9);


INSERT INTO
table VALUES (1,2,3),

                         (4,5,6),

                         (7,8,9);

Teradata tiene el concepto de solicitud de varias instrucciones (MSR), que envía varias instrucciones INSERT a la vez. En BigQuery, no se recomienda debido al límite de transacción implícito entre las instrucciones. En su lugar, usa varios valores INSERT.

BigQuery permite instrucciones INSERT simultáneas, pero puede ponerlas en colaUPDATE. Para mejorar el rendimiento, puede hacer lo siguiente:

Combina varias filas en una sola instrucción INSERT, en lugar de una fila por operación INSERT.
Combina varias instrucciones de DML (incluida INSERT) mediante una instrucción MERGE.
Usa CREATE TABLE ... AS SELECT para crear y rellenar tablas en lugar de UPDATE o DELETE, sobre todo cuando hagas consultas en campos particionados o restauraciones o reversiones.

`UPDATE` declaración

La mayoría de las declaraciones de UPDATE Teradata son compatibles con BigQuery, excepto los siguientes elementos:

Cuando se usa una cláusula FROM, el orden de las cláusulas FROM y SET se invierte en Teradata y BigQuery.
En GoogleSQL, cada instrucción UPDATE debe incluir la palabra clave WHERE, seguida de una condición. Para actualizar todas las filas de la tabla, usa WHERE true.

Como práctica recomendada, debe agrupar varias mutaciones de DML en lugar de instrucciones UPDATE y INSERT individuales. Los scripts DML de BigQuery tienen una semántica de coherencia ligeramente diferente a las instrucciones equivalentes de Teradata. Para obtener una descripción general del aislamiento de instantáneas y la gestión de sesiones y transacciones, consulta la sección CREATE INDEX de este documento.

En la siguiente tabla se muestran las instrucciones de Teradata UPDATE y las instrucciones de BigQuery que realizan las mismas tareas.

Para obtener más información sobre UPDATE en BigQuery, consulta los ejemplos de UPDATE de BigQuery en la documentación de DML.

Teradata		BigQuery
`UPDATE table_A FROM table_A, table_B SET y = table_B.y, z = table_B.z + 1 WHERE table_A.x = table_B.x AND table_A.y IS NULL;`		`UPDATE table_A SET y = table_B.y, z = table_B.z + 1 FROM table_B WHERE table_A.x = table_B.x AND table_A.y IS NULL;`
`UPDATE table alias SET x = x + 1 WHERE f(x) IN (0, 1);`		`UPDATE table SET x = x + 1 WHERE f(x) IN (0, 1);`
`UPDATE table_A FROM table_A, table_B, B SET z = table_B.z WHERE table_A.x = table_B.x AND table_A.y = table_B.y;`		`UPDATE table_A SET z = table_B.z FROM table_B WHERE table_A.x = table_B.x AND table_A.y = table_B.y;`

`DELETE` y `TRUNCATE`

Las instrucciones DELETE y TRUNCATE son dos formas de eliminar filas de una tabla sin que se vean afectados el esquema ni los índices de la tabla. TRUNCATE elimina todos los datos, mientras que DELETE quita las filas seleccionadas de la tabla.

En BigQuery, la instrucción DELETE debe tener una cláusula WHERE. Para eliminar todas las filas de la tabla (truncar), usa WHERE true. Para acelerar las operaciones de truncado en tablas muy grandes, te recomendamos que uses la instrucción CREATE OR REPLACE TABLE ... AS SELECT y que utilices un LIMIT 0 en la misma tabla para sustituirse a sí misma. Sin embargo, asegúrate de añadir manualmente la información de partición y de agrupamiento en clústeres cuando la uses.

Teradata elimina las filas eliminadas más adelante. Esto significa que las operaciones DELETE son inicialmente más rápidas que en BigQuery, pero requieren recursos más adelante, sobre todo las operaciones DELETE a gran escala que afectan a la mayoría de una tabla. Para usar un enfoque similar en BigQuery, te recomendamos que reduzcas el número de operaciones de DELETE, por ejemplo, copiando las filas que no quieras eliminar en una tabla nueva. También puedes eliminar particiones completas. Ambas opciones están diseñadas para ser operaciones más rápidas que las mutaciones DML atómicas.

Para obtener más información sobre DELETE en BigQuery, consulta los DELETE ejemplos en la documentación de DML.

Teradata	BigQuery
`BEGIN TRANSACTION; LOCKING TABLE table_A FOR EXCLUSIVE; DELETE FROM table_A; INSERT INTO table_A SELECT * FROM table_B; END TRANSACTION;`	Sustituir el contenido de una tabla por el resultado de una consulta equivale a una transacción. Puedes hacerlo con una operación query o con una operación copy. Usar una operación de consulta: `bq query --replace --destination_table table_A 'SELECT * FROM table_B';` Usar una operación de copia: `bq cp -f table_A table_B`
`DELETE database.table ALL;`	`DELETE FROM table WHERE TRUE;` O bien, si se trata de tablas muy grandes, puedes hacerlo de forma más rápida: `CREATE OR REPLACE table AS SELECT * FROM table LIMIT 0;`

`MERGE` declaración

La instrucción MERGE puede combinar operaciones INSERT, UPDATE y DELETE en una sola instrucción "upsert" y realizar las operaciones de forma atómica. La operación MERGE debe coincidir con una fila de origen como máximo por cada fila de destino. Tanto BigQuery como Teradata siguen la sintaxis ANSI.

La operación MERGE de Teradata se limita a las claves principales coincidentes en un procesador de módulo de acceso (AMP). Por el contrario, BigQuery no tiene limitaciones de tamaño ni de columnas para las operaciones de MERGE, por lo que usar MERGE es una optimización útil. Sin embargo, si la MERGE es principalmente una eliminación de gran tamaño, consulta las optimizaciones para DELETE en otra parte de este documento.

Las secuencias de comandos DML de BigQuery tienen una semántica de coherencia ligeramente diferente a las instrucciones equivalentes de Teradata. Por ejemplo, las tablas SET de Teradata en modo de sesión pueden ignorar los duplicados durante una operación MERGE. Para obtener una descripción general sobre cómo gestionar tablas MULTISET y SET, el aislamiento de instantáneas y la gestión de sesiones y transacciones, consulta la sección CREATE INDEX de este documento.

Variables de filas afectadas

En Teradata, la variable ACTIVITY_COUNT es una extensión de Teradata ANSI SQL que contiene el número de filas afectadas por una instrucción DML.

La variable de sistema @@row_count de la función de scripting tiene una función similar. En BigQuery, es más habitual comprobar el valor devuelto de numDmlAffectedRows en los registros de auditoría o en las vistas INFORMATION_SCHEMA.

Sintaxis de DDL

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

`CREATE TABLE` declaración

La mayoría de las instrucciones de Teradata CREATE TABLE son compatibles con BigQuery, excepto los siguientes elementos de sintaxis, que no se usan en BigQuery:

MULTISET. Consulta la sección CREATE INDEX.
VOLATILE. Consulta la sección Tablas temporales.
[NO] FALLBACK. Consulta la sección Restaurar versión anterior.
[NO] BEFORE JOURNAL, [NO] AFTER JOURNAL
CHECKSUM = DEFAULT | val
DEFAULT MERGEBLOCKRATIO
PRIMARY INDEX (col, ...). Consulta la sección CREATE INDEX.
UNIQUE PRIMARY INDEX. Consulta la sección CREATE INDEX.
CONSTRAINT
DEFAULT
IDENTITY

Para obtener más información sobre CREATE TABLE en BigQuery, consulta los ejemplos de CREATE de BigQuery en la documentación de DML.

Opciones y atributos de columna

Las siguientes especificaciones de columna de la instrucción CREATE TABLE no se usan en BigQuery:

FORMAT 'format'. Consulta la sección Formato de tipos de Teradata.
CHARACTER SET name. BigQuery siempre usa la codificación UTF-8.
[NOT] CASESPECIFIC
COMPRESS val | (val, ...)

Teradata amplía el estándar ANSI con una columna TITLE opción. Esta función se puede implementar de forma similar en BigQuery mediante la descripción de la columna, tal como se muestra en la siguiente tabla. Ten en cuenta que esta opción no está disponible para las vistas.

Teradata	BigQuery
`CREATE TABLE table ( col1 VARCHAR(30) TITLE 'column desc' );`	`CREATE TABLE dataset.table ( col1 STRING OPTIONS(description="column desc") );`

Tablas temporales

Teradata admite tablas volátiles, que se suelen usar para almacenar resultados intermedios en secuencias de comandos. Hay varias formas de conseguir algo similar a las tablas volátiles en BigQuery:

CREATE TEMPORARY TABLE se puede usar en Secuencias de comandos y es válido durante el tiempo de vida de la secuencia de comandos. Si la tabla tiene que existir más allá de una secuencia de comandos, puedes usar las otras opciones de esta lista.
Tiempo de vida del conjunto de datos: crea un conjunto de datos con un tiempo de vida corto (por ejemplo, 1 hora) para que las tablas creadas en el conjunto de datos sean temporales, ya que no se conservarán más tiempo que el tiempo de vida del conjunto de datos. Puedes añadir el prefijo temp a todos los nombres de las tablas de este conjunto de datos para indicar claramente que las tablas son temporales.
TTL de tabla: crea una tabla que tenga un tiempo de vida breve específico de la tabla mediante instrucciones DDL similares a las siguientes:
```
CREATE TABLE temp.name (col1, col2, ...)
OPTIONS(expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR));
```
Cláusula WITH: si solo se necesita una tabla temporal en el mismo bloque, usa un resultado temporal con una instrucción o subconsulta WITH. Esta es la opción más eficiente.

Un patrón que se usa a menudo en las secuencias de comandos de Teradata (BTEQ) es crear una tabla permanente, insertar un valor en ella, usarla como una tabla temporal en las instrucciones en curso y, a continuación, eliminar o truncar la tabla. De hecho, se usa la tabla como una variable constante (un semáforo). Este enfoque no es eficiente en BigQuery, por lo que te recomendamos que uses variables reales en secuencias de comandos o que uses CREATE OR REPLACE con la sintaxis de consulta AS SELECT para crear una tabla que ya tenga valores.

`CREATE VIEW` declaración

En la siguiente tabla se muestran las equivalencias entre Teradata y BigQuery para la instrucción CREATE VIEW. Las cláusulas para bloquear tablas, como LOCKING ROW FOR ACCESS, no son necesarias en BigQuery.

Teradata	BigQuery	Notas
`CREATE VIEW view_name AS SELECT ...`	`CREATE VIEW view_name AS SELECT ...`
`REPLACE VIEW view_name AS SELECT ...`	`CREATE OR REPLACE VIEW view_name AS SELECT ...`
No compatible	`CREATE VIEW IF NOT EXISTS OPTIONS(view_option_list) AS SELECT ...`	Crea una vista solo si no existe en el conjunto de datos especificado.

`CREATE [UNIQUE] INDEX` declaración

Teradata requiere índices para todas las tablas y soluciones alternativas especiales, como las tablas MULTISET y las NoPI Tables, para trabajar con datos no únicos o no indexados.

BigQuery no requiere índices. En esta sección se describen los enfoques de BigQuery para crear funciones similares a las que se usan en Teradata cuando hay una necesidad real de lógica empresarial.

Indexación para mejorar el rendimiento

Como se trata de una base de datos orientada a columnas con optimización de consultas y almacenamiento, BigQuery no necesita índices explícitos. BigQuery ofrece funciones como la creación de particiones y clústeres y los campos anidados, que pueden aumentar la eficiencia y el rendimiento de las consultas al optimizar la forma en que se almacenan los datos.

Teradata no admite vistas materializadas. Sin embargo, ofrece índices de unión mediante la instrucción CREATE JOIN INDEX, que materializa los datos necesarios para una unión. BigQuery no necesita índices materializados para acelerar el rendimiento, al igual que no necesita espacio de cola dedicado para las combinaciones.

En otros casos de optimización, se pueden usar vistas materializadas.

Indexación para la coherencia (UNIQUE, PRIMARY INDEX)

En Teradata, se puede usar un índice único para evitar que haya filas con claves no únicas en una tabla. Si un proceso intenta insertar o actualizar datos que tienen un valor que ya está en el índice, la operación falla con una infracción del índice (tablas MULTISET) o se ignora de forma silenciosa (tablas SET).

Como BigQuery no proporciona índices explícitos, se puede usar una instrucción MERGE para insertar solo registros únicos en una tabla de destino desde una tabla de almacenamiento provisional y descartar los registros duplicados. Sin embargo, no hay forma de evitar que un usuario con permisos de edición inserte un registro duplicado, ya que BigQuery nunca se bloquea durante las operaciones de INSERT. Para generar un error de registros duplicados en BigQuery, puedes usar una instrucción MERGE de una tabla de almacenamiento provisional, como se muestra en el siguiente ejemplo.

Teradata		BigQuery
`CREATE [UNIQUE] INDEX name;`		MERGE `prototype.FIN_MERGE` t USING `prototype.FIN_TEMP_IMPORT` m ON t.col1 = m.col1 AND t.col2 = m.col2 WHEN MATCHED THEN UPDATE SET t.col1 = ERROR(CONCAT('Encountered error for ', m.col1, ' ', m.col2)) WHEN NOT MATCHED THEN INSERT (col1,col2,col3,col4,col5,col6,col7,col8) VALUES(col1,col2,col3,col4,col5,col6,CURRENT_TIMESTAMP(),CURRENT_TIMESTAMP());

En la mayoría de los casos, los usuarios prefieren eliminar los duplicados por su cuenta para encontrar errores en los sistemas posteriores.
BigQuery no admite columnas DEFAULT y IDENTITY (secuencias).

Indexación para conseguir el bloqueo

Teradata proporciona recursos en el procesador del módulo de acceso (AMP). Las consultas pueden consumir recursos de todos los AMP, de un solo AMP o de un grupo de AMP. Las instrucciones DDL son todas AMP y, por lo tanto, similares a un bloqueo DDL global. BigQuery no tiene un mecanismo de bloqueo como este y puede ejecutar consultas simultáneas y declaraciones INSERT hasta alcanzar tu cuota. Solo las declaraciones de DML UPDATE simultáneas tienen ciertas implicaciones de simultaneidad: las operaciones UPDATE en la misma partición se ponen en cola para asegurar el aislamiento de la instantánea, por lo que no tienes que bloquear para evitar lecturas fantasma o actualizaciones perdidas.

Debido a estas diferencias, los siguientes elementos de Teradata no se usan en BigQuery:

ON COMMIT DELETE ROWS;
ON COMMIT PRESERVE ROWS;

Declaraciones SQL procedimentales

En esta sección se describe cómo convertir las instrucciones de SQL de procedimiento que se usan en procedimientos almacenados, funciones y activadores de Teradata a secuencias de comandos, procedimientos o funciones definidas por el usuario (UDFs) de BigQuery. Los administradores del sistema pueden consultar todos estos elementos mediante las vistas de INFORMATION_SCHEMA.

`CREATE PROCEDURE` declaración

Los procedimientos almacenados se admiten como parte de las secuencias de comandos de BigQuery.

En BigQuery, el término "secuencia de comandos" hace referencia a cualquier uso de instrucciones de control, mientras que los procedimientos son secuencias de comandos con nombre (con argumentos si es necesario) que se pueden llamar desde otras secuencias de comandos y almacenar de forma permanente, si es necesario. También se pueden escribir funciones definidas por el usuario (UDF) en JavaScript.

Teradata	BigQuery
`CREATE PROCEDURE`	`CREATE PROCEDURE` si se requiere un nombre; de lo contrario, usa el formato insertado con `BEGIN` o en una sola línea con `CREATE TEMP FUNCTION`.
`REPLACE PROCEDURE`	`CREATE OR REPLACE PROCEDURE`
`CALL`	`CALL`

En las siguientes secciones se describen formas de convertir las instrucciones de procedimiento de Teradata en instrucciones de secuencias de comandos de BigQuery que tengan una funcionalidad similar.

Declaración y asignación de variables

Las variables de BigQuery son válidas durante la vida útil de la secuencia de comandos.

Teradata	BigQuery
`DECLARE`	`DECLARE`
`SET`	`SET`

Controladores de condiciones de error

Teradata usa controladores en códigos de estado en procedimientos para controlar los errores. En BigQuery, la gestión de errores es una función principal del flujo de control principal, similar a lo que ofrecen otros lenguajes con los bloques TRY ... CATCH.

Teradata	BigQuery
`DECLARE EXIT HANDLER FOR SQLEXCEPTION`	`BEGIN ... EXCEPTION WHEN ERROR THEN`
`SIGNAL sqlstate`	`RAISE message`
`DECLARE CONTINUE HANDLER FOR SQLSTATE VALUE 23505;`	BigQuery no usa los controladores de excepciones que se activan en determinadas condiciones de error. Recomendamos usar instrucciones `ASSERT` cuando se utilicen condiciones de salida para comprobaciones previas o depuración, ya que cumplen el estándar ANSI SQL:2011.

La variable SQLSTATE de Teradata es similar a la variable de sistema @@error de BigQuery. En BigQuery, es más habitual investigar los errores mediante los registros de auditoría o las vistas INFORMATION_SCHEMA.

Declaraciones y operaciones de cursores

Como BigQuery no admite cursores ni sesiones, las siguientes instrucciones no se usan en BigQuery:

DECLARE cursor_name CURSOR [FOR | WITH] ...
PREPARE stmt_id FROM sql_str;
OPEN cursor_name [USING var, ...];
FETCH cursor_name INTO var, ...;
CLOSE cursor_name;

Instrucciones SQL dinámicas

La función de secuencias de comandos de BigQuery admite instrucciones SQL dinámicas como las que se muestran en la siguiente tabla.

Teradata	BigQuery
`EXECUTE IMMEDIATE sql_str;`	`EXECUTE IMMEDIATE sql_str;`
`EXECUTE stmt_id [USING var,...];`	`EXECUTE IMMEDIATE stmt_id USING var;`

Las siguientes instrucciones de SQL dinámico no se usan en BigQuery:

PREPARE stmt_id FROM sql_str;

Instrucciones de flujo de control

La función de secuencias de comandos de BigQuery admite instrucciones de flujo de control como las que se muestran en la siguiente tabla.

Teradata	BigQuery
`IF condition THEN stmts ELSE stmts END IF`	`IF condition THEN stmts ELSE stmts END IF`
`label_name: LOOP stmts END LOOP label_name;`	Las construcciones de bloques de estilo GOTO no se usan en BigQuery. Te recomendamos que las reescribas como funciones definidas por el usuario (UDFs) o que uses instrucciones `ASSERT` cuando se utilicen para gestionar errores.
`REPEAT stmts UNTIL condition END REPEAT;`	`WHILE condition DO stmts END WHILE`
`LEAVE outer_proc_label;`	`LEAVE` no se usa en los bloques de tipo GOTO, sino como sinónimo de `BREAK` para salir de un bucle `WHILE`.
`LEAVE label;`	`LEAVE` no se usa en los bloques de tipo GOTO, sino como sinónimo de `BREAK` para salir de un bucle `WHILE`.
`WITH RECURSIVE temp_table AS ( ... );`	Las consultas recursivas (también conocidas como expresiones de tabla comunes recursivas) no se usan en BigQuery. Se pueden reescribir usando arrays de `UNION ALL`.

Las siguientes instrucciones de flujo de control no se usan en BigQuery porque BigQuery no usa cursores ni sesiones:

FOR var AS SELECT ... DO stmts END FOR;
FOR var AS cur CURSOR FOR SELECT ... DO stmts END FOR;

Declaraciones SQL de metadatos y transacciones

Teradata	BigQuery
`HELP TABLE table_name;` `HELP VIEW view_name;`	`SELECT * EXCEPT(is_generated, generation_expression, is_stored, is_updatable) FROM mydataset.INFORMATION_SCHEMA.COLUMNS; WHERE table_name=table_name` La misma consulta es válida para obtener información de las columnas de las vistas. Para obtener más información, consulta la vista Columna en BigQuery `INFORMATION_SCHEMA`.
`SELECT * FROM dbc.tables WHERE tablekind = 'T';` (Vista DBC de Teradata)	`SELECT * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES;` Para obtener más información, consulta la introducción a BigQuery`INFORMATION_SCHEMA`.
`HELP STATISTICS table_name;`	`APPROX_COUNT_DISTINCT(col)`
`COLLECT STATS USING SAMPLE ON table_name column (...);`	No se usa en BigQuery.
`LOCKING TABLE table_name FOR EXCLUSIVE;`	BigQuery siempre usa el aislamiento de la instantánea. Para obtener más información, consulta Garantías de coherencia en otra sección de este documento.
`SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL ...`	BigQuery siempre usa el aislamiento de instantáneas. Para obtener más información, consulta la sección Garantías de coherencia de este documento.
`BEGIN TRANSACTION; SELECT ... END TRANSACTION;`	BigQuery siempre usa el aislamiento de instantáneas. Para obtener más información, consulta la sección Garantías de coherencia de este documento.
`EXPLAIN ...`	No se usa en BigQuery. Las funciones similares son la explicación del plan de consulta en la interfaz web de BigQuery y la asignación de ranuras visible en las `INFORMATION_SCHEMA` vistas y en el registro de auditoría de Cloud Monitoring.
`BEGIN TRANSACTION; SELECT ... END TRANSACTION;`	`BEGIN BEGIN TRANSACTION; COMMIT TRANSACTION; EXCEPTION WHEN ERROR THEN -- Roll back the transaction inside the exception handler. SELECT @@error.message; ROLLBACK TRANSACTION; END;`

Instrucciones SQL de varias líneas y con varias instrucciones

Tanto Teradata como BigQuery admiten transacciones (sesiones) y, por lo tanto, admiten instrucciones separadas por puntos y comas que se ejecutan de forma coherente. Para obtener más información, consulta el artículo sobre las transacciones con varias declaraciones.

Códigos y mensajes de error

Los códigos de error de Teradata y BigQuery son diferentes. BigQuery proporciona una API REST y se basa principalmente en códigos de estado HTTP y mensajes de error detallados.

Si la lógica de tu aplicación detecta los siguientes errores, intenta eliminar la fuente del error, ya que BigQuery no devolverá los mismos códigos de error.

SQLSTATE = '02000': "No se ha encontrado la fila"
SQLSTATE = '21000': "Infracción de cardinalidad (índice único)"
SQLSTATE = '22000'—"Infracción de datos (tipo de datos)"
SQLSTATE = '23000': "Constraint Violation" ("Infracción de restricción")

En BigQuery, es más habitual usar las vistas INFORMATION_SCHEMA o los registros de auditoría para analizar los errores en profundidad.

Para obtener información sobre cómo gestionar los errores en las secuencias de comandos, consulta las secciones siguientes.

Garantías de coherencia y aislamiento de transacciones

Tanto Teradata como BigQuery son atómicos, es decir, cumplen los requisitos de ACID a nivel de mutación en muchas filas. Por ejemplo, una operación MERGE es completamente atómica, incluso con varios valores insertados y actualizados.

Transacciones

Teradata proporciona el nivel de aislamiento de la transacción Serializable o Read Uncommitted (que permite lecturas sucias) al ejecutarse en el modo de sesión (en lugar del modo de confirmación automática). En el mejor de los casos, Teradata consigue un aislamiento estrictamente serializable mediante el bloqueo pesimista de un hash de fila en todas las columnas de las filas de todas las particiones. Es posible que se produzcan interbloqueos. DDL siempre fuerza un límite de transacción. Los trabajos de Teradata Fastload se ejecutan de forma independiente, pero solo en tablas vacías.

BigQuery también admite transacciones. BigQuery ayuda a garantizar el control de simultaneidad optimista (el primero en confirmar gana) con el aislamiento de instantáneas, en el que una consulta lee los últimos datos confirmados antes de que empiece. Este enfoque garantiza el mismo nivel de coherencia por fila y por mutación, así como entre las filas de la misma instrucción DML, pero evita los interbloqueos. En el caso de que haya varias instrucciones UPDATE en la misma tabla, BigQuery cambia al control de simultaneidad pesimista y pone en cola varias instrucciones UPDATE, y vuelve a intentarlo automáticamente en caso de conflicto. INSERT Las instrucciones DML y las tareas de carga se pueden ejecutar de forma simultánea e independiente para añadir datos a las tablas.

Restauración

Teradata admite dos modos de reversión de sesiones, el modo de sesión ANSI y el modo de sesión de Teradata (SET SESSION CHARACTERISTICS y SET SESSION TRANSACTION), en función del modo de reversión que quieras. En caso de error, es posible que la transacción no se revierta.

BigQuery admite la instrucción ROLLBACK TRANSACTION. No hay ninguna declaración ABORT en BigQuery.

Límites de las bases de datos

Consulte siempre la documentación pública de BigQuery para ver las cuotas y los límites más recientes. Muchas cuotas para usuarios con grandes volúmenes se pueden aumentar poniéndose en contacto con el equipo de Asistencia de Cloud. En la siguiente tabla se comparan los límites de las bases de datos de Teradata y BigQuery.

Límite	Teradata	BigQuery
Tablas por base de datos	Sin restricción	Sin restricción
Columnas por tabla	2048	10.000
Tamaño máximo de las filas	1 MB	100 MB
Longitud del nombre de la columna	128 caracteres Unicode	300 caracteres Unicode
Longitud de la descripción de la tabla	128 caracteres Unicode	16.384 caracteres Unicode
Filas por tabla	Ilimitado	Ilimitado
Longitud máxima de las solicitudes de SQL	1 MB	1 MB (longitud máxima de las consultas de GoogleSQL sin resolver) 12 MB (longitud máxima de las consultas de SQL antiguo y GoogleSQL resueltas) Streaming: 10 MB (límite de tamaño de la solicitud HTTP) 10.000 (número máximo de filas por solicitud)
Tamaño máximo de solicitud y respuesta	7 MB (solicitud) y 16 MB (respuesta)	10 MB (solicitud) y 10 GB (respuesta), o prácticamente ilimitado si usas la paginación o la API de Cloud Storage.
Número máximo de sesiones simultáneas	120 por motor de análisis (PE)	1000 consultas simultáneas con varias instrucciones (se puede aumentar con una reserva de ranura). 300 solicitudes a API simultáneas por usuario.
Número máximo de cargas (rápidas) simultáneas	30 (valor predeterminado: 5)	No hay límite de simultaneidad; los trabajos se ponen en cola. 100.000 tareas de carga por proyecto y día.