Guía de traducción de Amazon Redshift SQL
En este documento, se detallan las similitudes y diferencias que existen en la sintaxis de Amazon Redshift 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 de forma masiva o la traducción de SQL interactiva a fin de traducir consultas ad hoc.
El público previsto para esta guía son arquitectos empresariales, administradores de bases de datos, desarrolladores de aplicaciones y especialistas en seguridad de TI. Suponemos que estás familiarizado con Amazon Redshift.
Tipos de datos
En esta sección, se muestran los equivalentes entre los tipos de datos en Amazon Redshift y en BigQuery.
Amazon Redshift | BigQuery | Notas | |
---|---|---|---|
Tipo de datos | Alias | Tipo de datos | |
SMALLINT |
INT2 |
INT64 |
El SMALLINT de Amazon Redshift es de 2 bytes, mientras que el INT64 de BigQuery es de 8 bytes. |
INTEGER |
INT64 |
El INTEGER de Amazon Redshift es de 4 bytes, mientras que el INT64 de BigQuery es de 8 bytes. |
|
BIGINT |
INT8 |
INT64 |
Los BIGINT de Amazon Redshift y INT64 de BigQuery son de 8 bytes. |
DECIMAL |
NUMERIC |
NUMERIC |
|
REAL |
FLOAT4 |
FLOAT64 |
El REAL de Amazon Redshift es de 4 bytes, mientras que el FLOAT64 de BigQuery es de 8 bytes. |
DOUBLE
PRECISION |
FLOAT64 |
||
BOOLEAN |
BOOL |
BOOL |
BOOLEAN de Amazon Redshift puede usar TRUE , t , true , y , yes y 1 como valores literales válidos para verdadero. El tipo de datos BOOL de BigQuery usa TRUE que no distingue mayúsculas de minúsculas. |
CHAR |
STRING |
||
VARCHAR |
STRING |
||
DATE |
DATE |
||
TIMESTAMP |
TIMESTAMP WITHOUT TIME ZONE |
DATETIME |
|
TIMESTAMPTZ |
TIMESTAMP |
Nota: En BigQuery, se usan las zonas horarias cuando se analizan o se formatean las marcas de tiempo para visualización. Una marca de tiempo con formato de string puede incluir una zona horaria, pero cuando BigQuery analiza la string, almacena la marca de tiempo en la hora UTC equivalente. Cuando una zona horaria no se especifica de forma explícita, se usa la zona horaria predeterminada, UTC. Nombres de zona horaria O bien, puedes hacer lo siguiente:compensación de UTC se usa (-|+)HH:MM, pero no se admiten las abreviaturas de zona horaria, como PDT. | |
GEOMETRY |
GEOGRAPHY |
Compatibilidad con consultas de datos geoespaciales. |
BigQuery también tiene los siguientes tipos de datos que no tienen un análogo de Amazon Redshift directo:
Tipos de conversiones implícitas
Cuando migras a BigQuery, debes convertir la mayoría de tus conversións implícitas de Amazon Redshift en conversiones explícitas de BigQuery, excepto para los siguientes tipos de datos, que BigQuery convierte de forma implícita.
BigQuery realiza conversiones implícitas para los siguientes tipos de datos:
Desde el tipo de BigQuery | Hasta tipo de BigQuery |
---|---|
|
|
|
|
|
|
BigQuery también realiza conversiones implícitas para los siguientes literales:
Desde el tipo de BigQuery | Hasta tipo de BigQuery |
---|---|
Literal de STRING
(p. ej., “25-12-2008”) |
|
Literal de STRING
(p. ej., “2008-12-25 15:30:00”) |
|
Literal de STRING (p.ej., “2008-12-25T07:30:00”) |
|
Literal de STRING
(p.ej., “15:30:00”) |
|
Tipos de conversiones explícitas
Puedes convertir los tipos de datos de Amazon Redshift que BigQuery no convierte de forma implícita mediante el uso de la función CAST(expression AS type)
de BigQuery o cualquiera de las funciones de conversión DATE
o TIMESTAMP
.
Cuando migres tus consultas, cambia cualquier caso de la función CONVERT(type, expression)
de Amazon Redshift (o la sintaxis ::) a la función CAST(expression AS type)
de BigQuery, como se muestra en la tabla de la sección Funciones de formato de tipo de datos.
Sintaxis de las consultas
En esta sección, se abordan las diferencias que existen en la sintaxis de consultas en Amazon Redshift y BigQuery.
Declaración SELECT
La mayoría de las declaraciones SELECT
de Amazon Redshift son compatibles con BigQuery. En la siguiente tabla, se incluye una lista de diferencias menores.
Amazon Redshift | BigQuery |
---|---|
|
|
|
|
BigQuery también admite las siguientes expresiones en declaraciones SELECT
, que no tienen un equivalente de Amazon Redshift:
Cláusula FROM
Una cláusula FROM
en una consulta enumera las referencias de la tabla de las que se seleccionan los datos. En Amazon Redshift, las referencias de tablas posibles incluyen tablas, vistas y subconsultas. BigQuery admite todas estas referencias de tabla.
Se puede 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 tabla 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 un
STRUCT
). - Arrays planos.
JOIN
tipos
Amazon Redshift y BigQuery admiten los siguientes tipos de unión:
[INNER] JOIN
LEFT [OUTER] JOIN
RIGHT [OUTER] JOIN
FULL [OUTER] JOIN
CROSS JOIN
y la unión cruzada con comas implícita equivalente.
En la siguiente tabla, se incluye una lista de diferencias menores.
Amazon Redshift | BigQuery |
---|---|
|
Nota: En BigQuery, las cláusulas JOIN requieren una condición JOIN , a menos que la cláusula sea CROSS
JOIN o una de las tablas unidas sea un campo dentro de un tipo de datos o un arreglo. |
Cláusula WITH
Una cláusula WITH
de BigQuery contiene una o más subconsultas con nombre que se ejecutan cuando una declaración SELECT
posterior hace referencia a estas. Las cláusulas WITH
de Amazon Redshift se comportan de la misma manera que las de BigQuery, excepto que puedes evaluar la cláusula una vez y volver a usar los resultados.
Configurar operadores
Existen algunas diferencias menores entre los operadores de conjuntos de Amazon Redshift y los operadores de conjuntos de BigQuery. Sin embargo, todas las operaciones de conjunto que son posibles en Amazon Redshift se pueden replicar en BigQuery.
Amazon Redshift | BigQuery |
---|---|
|
Nota: BigQuery y Amazon Redshift admiten el operador |
|
|
|
|
|
|
|
Nota: BigQuery requiere paréntesis para separar diferentes operaciones de conjuntos. Si se repite el mismo operador de conjunto, no se necesitan los paréntesis. |
Cláusula ORDER BY
Hay algunas diferencias menores entre las cláusulas ORDER BY
de Amazon Redshift y las cláusulas ORDER BY
de BigQuery.
Amazon Redshift | BigQuery |
---|---|
En Amazon Redshift, los NULL se clasifican en último lugar de forma predeterminada (orden ascendente). |
En BigQuery, los NULL se clasifican primero de forma predeterminada (orden ascendente). |
|
Nota: BigQuery no usa la sintaxis LIMIT ALL , pero ORDER BY ordena todas las filas de forma predeterminada, lo que genera el mismo comportamiento que la cláusula LIMIT ALL de Amazon Redshift. Recomendamos incluir una cláusula LIMIT con cada cláusula ORDER BY . Si ordenas todas las filas de resultados, se degradará innecesariamente el rendimiento de la ejecución de consultas. |
|
Nota: En BigQuery, se debe usar OFFSET junto con una cantidad de LIMIT . Asegúrate de configurar el valor INT64 de la cantidad como el mínimo de filas ordenadas necesarias.
Si ordenas todas las filas de resultados se degrada de forma innecesaria el rendimiento de la ejecución de consultas. |
Condiciones
En la siguiente tabla, se muestran las condiciones de Amazon Redshift, o predicados, que son específicas de Amazon Redshift y deben convertirse en su equivalente de BigQuery.
Amazon Redshift | BigQuery |
---|---|
|
|
|
|
|
|
|
Nota: BigQuery no admite caracteres de escape personalizados. Debes usar dos barras invertidas (“\\”) como caracteres de escape para BigQuery. |
|
Nota: Si se especifica NOT , encierra la expresión IF anterior en una expresión NOT como se muestra a continuación:
|
|
|
Funciones
En las siguientes secciones, se enumeran las funciones de Amazon Redshift y sus equivalentes de BigQuery.
Funciones de agregación
En la siguiente tabla, se muestran las asignaciones entre las funciones comunes de agregación de Amazon Redshift, analítica agregada y agregación aproximada con sus equivalentes de BigQuery.
Amazon Redshift | BigQuery |
---|---|
APPROXIMATE
COUNT(DISTINCT expression) |
APPROX_COUNT_DISTINCT(expression) |
APPROXIMATE
PERCENTILE_DISC( |
APPROX_QUANTILES(expression,
100) |
AVG([DISTINCT] expression) |
AVG([DISTINCT] expression) |
COUNT(expression) |
COUNT(expression) |
LISTAGG( |
STRING_AGG( |
MAX(expression) |
MAX(expression) |
MEDIAN(median_expression) |
PERCENTILE_CONT( median_expression, 0.5
) OVER() |
MIN(expression) |
MIN(expression) |
PERCENTILE_CONT( |
PERCENTILE_CONT( Nota: No abarca casos prácticos de agregación. |
STDDEV([DISTINCT] expression) |
STDDEV([DISTINCT] expression) |
STDDEV_SAMP([DISTINCT] expression) |
STDDEV_SAMP([DISTINCT] expression) |
STDDEV_POP([DISTINCT] expression) |
STDDEV_POP([DISTINCT] expression) |
SUM([DISTINCT] expression) |
SUM([DISTINCT] expression) |
VARIANCE([DISTINCT] expression) |
VARIANCE([DISTINCT] expression) |
VAR_SAMP([DISTINCT] expression) |
VAR_SAMP([DISTINCT] expression) |
VAR_POP([DISTINCT] expression) |
VAR_POP([DISTINCT] expression) |
BigQuery también ofrece las siguientes funciones de agregación, analítica agregada y agregación aproximada, que no tienen un análogo directo en Amazon Redshift:
ANY_VALUE
APPROX_TOP_COUNT
APPROX_TOP_SUM
ARRAY_AGG
ARRAY_CONCAT_AGG
COUNTIF
CORR
COVAR_POP
COVAR_SAMP
Funciones de agregación a nivel de bits
En la siguiente tabla, se muestran las asignaciones entre las funciones comunes de Amazon Redshift a nivel de bits con sus equivalentes de BigQuery.
Amazon Redshift | BigQuery |
---|---|
BIT_AND(expression) |
BIT_ADD(expression) |
BIT_OR(expression) |
BIT_OR(expression) |
BOOL_AND>(expression) |
LOGICAL_AND(expression) |
BOOL_OR(expression) |
LOGICAL_OR(expression) |
BigQuery también ofrece la siguiente función de agregación a nivel de bits, que no tiene un análogo directo en Amazon Redshift:
Funciones analíticas
En la siguiente tabla, se muestran las asignaciones entre las funciones comunes de la ventana de Amazon Redshift con sus equivalentes de BigQuery. Las funciones analíticas en BigQuery incluyen lo siguiente: Funciones de agregación analítica, funciones agregadas, funciones de navegación y funciones de numeración.
Amazon Redshift | BigQuery |
---|---|
AVG(expression) OVER |
AVG(expression) OVER |
COUNT(expression) OVER |
COUNT(expression) OVER |
CUME_DIST() OVER |
CUME_DIST() OVER |
DENSE_RANK() OVER |
DENSE_RANK() OVER |
FIRST_VALUE(expression)
OVER |
FIRST_VALUE(expression)
OVER |
LAST_VALUE(expression) OVER |
LAST_VALUE(expression) OVER |
LAG(value_expr [, offset])
OVER |
LAG(value_expr [, offset])
OVER |
LEAD(value_expr [, offset])
OVER |
LEAD(value_expr [, offset])
OVER |
LISTAGG( |
STRING_AGG( |
MAX(expression) OVER |
MAX(expression) OVER |
MEDIAN(median_expression)
OVER |
PERCENTILE_CONT( |
MIN(expression) OVER |
MIN(expression) OVER |
NTH_VALUE(expression,
offset) OVER (
[PARTITION BY window_partition] [ORDER BY window_ordering
frame_clause]
) |
NTH_VALUE(expression,
offset) OVER |
NTILE(expr) OVER |
NTILE(expr) OVER |
PERCENT_RANK() OVER |
PERCENT_RANK() OVER |
PERCENTILE_CONT(percentile)
|
PERCENTILE_CONT(expr,
percentile) OVER |
PERCENTILE_DISC(percentile)
WITHIN GROUP (ORDER BY expr) OVER |
PERCENTILE_DISC(expr,
percentile) OVER |
RANK() OVER |
RANK() OVER |
RATIO_TO_REPORT(ratio_expression)
OVER |
ratio_expression SUM(ratio_expression) OVER |
ROW_NUMBER() OVER |
ROW_NUMBER() OVER |
STDDEV(expression) OVER |
STDDEV(expression) OVER |
STDDEV_SAMP(expression)
OVER |
STDDEV_SAMP(expression)
OVER |
STDDEV_POP(expression) OVER |
STDDEV_POP(expression) OVER |
SUM(expression) OVER |
SUM(expression) OVER |
VAR_POP(expression) OVER |
VAR_POP(expression) OVER |
VAR_SAMP(expression) OVER |
VAR_SAMP(expression) OVER |
VARIANCE(expression) OVER |
VARIANCE(expression) OVER |
Expresiones condicionales
En la siguiente tabla, se muestran las asignaciones entre expresiones condicionales comunes de Amazon Redshift con sus equivalentes de BigQuery.
Amazon Redshift | BigQuery |
---|---|
CASEexpression |
CASE expression |
COALESCE(expression1[,
...]) |
COALESCE(expression1[,
...]) |
DECODE( |
CASE expression |
GREATEST(value [,
...]) |
GREATEST(value [,
...]) |
LEAST(value [, ...]) |
LEAST(value [, ...]) |
NVL(expression1[, ...])
|
COALESCE(expression1[,
...]) |
NVL2( |
IF( |
NULLIF(expression1,
expression2) |
NULLIF(expression1,
expression2) |
BigQuery también ofrece las siguientes expresiones condicionales, que no tienen un análogo directo en Amazon Redshift:
Funciones de fecha y hora
En la siguiente tabla, se muestran las asignaciones entre las funciones comunes de fecha y hora de Amazon Redshift con sus equivalentes de BigQuery. Las funciones de tiempo y datos de BigQuery incluyen funciones de fecha, fecha y hora funciones, funciones de tiempo y funciones de marca de tiempo.
Ten en cuenta que las funciones que parecen idénticas en Amazon Redshift y BigQuery pueden mostrar diferentes tipos de datos.
Amazon Redshift | BigQuery |
---|---|
ADD_MONTHS( |
CAST( DATE_ADD( |
timestamptz_or_timestamp AT TIME
ZONE timezone |
PARSE_TIMESTAMP( Nota: Las zonas horarias se usan cuando se analizan o se formatean las marcas de tiempo para fines de visualización. Una marca de tiempo con formato de string puede incluir una zona horaria, pero cuando BigQuery analiza la string, almacena la marca de tiempo en la hora UTC equivalente. Cuando una zona horaria no se especifica de forma explícita, se usa la zona horaria predeterminada, UTC. Se admiten nombres de zonas horarias o compensación de UTC (-HH:MM), pero no se admiten las abreviaturas de zona horaria (como PDT). |
CONVERT_TIMEZONE( |
PARSE_TIMESTAMP( Nota: source_timezone es UTC en BigQuery. |
CURRENT_DATE Nota: Muestra la fecha de inicio de la transacción actual en la zona horaria actual de la sesión (UTC de forma predeterminada). |
CURRENT_DATE() Nota: Muestra la fecha de inicio de la declaración actual en la zona horaria UTC. |
DATE_CMP(date1, date2)
|
CASE |
DATE_CMP_TIMESTAMP(date1,
date2) |
CASE |
DATE_CMP_TIMESTAMPTZ(date,
timestamptz) |
CASE |
DATE_PART_YEAR(date) |
EXTRACT(YEAR FROM
date) |
DATEADD(date_part,
interval, date) |
CAST( |
DATEDIFF( |
DATE_DIFF( |
DATE_PART(date_part, date)
|
EXTRACT(date_part FROM
date) |
DATE_TRUNC('date_part',
timestamp) |
TIMESTAMP_TRUNC(timestamp,
date_part) |
EXTRACT(date_part FROM
timestamp) |
EXTRACT(date_part FROM
timestamp) |
GETDATE() |
PARSE_TIMESTAMP( |
INTERVAL_CMP( |
En los intervalos de Redshift, hay 360 días en un año.
En BigQuery, puedes usar la siguiente función definida por el usuario (UDF) para analizar un intervalo de Redshift y traducirlo a segundos. CREATE TEMP FUNCTION Para comparar los literales de intervalo, realiza lo siguiente: IF( |
LAST_DAY(date) |
DATE_SUB( |
MONTHS_BETWEEN( |
DATE_DIFF( |
NEXT_DAY(date, day) |
DATE_ADD( |
SYSDATE Nota: Muestra la marca de tiempo de inicio de la transacción actual en la zona horaria de la sesión actual (UTC de forma predeterminada). |
CURRENT_TIMESTAMP() Nota: Muestra una marca de tiempo de inicio para la declaración actual en la zona horaria UTC. |
TIMEOFDAY() |
FORMAT_TIMESTAMP( |
TIMESTAMP_CMP( |
CASE |
TIMESTAMP_CMP_DATE( |
CASE |
TIMESTAMP_CMP_TIMESTAMPTZ(
Nota: Redshift compara las marcas de tiempo en la zona horaria definida por la sesión de usuario. La zona horaria predeterminada de la sesión del usuario es UTC. |
CASE Nota: BigQuery compara las marcas de tiempo en la zona horaria UTC. |
TIMESTAMPTZ_CMP( Nota: Redshift compara las marcas de tiempo en la zona horaria definida por la sesión de usuario. La zona horaria predeterminada de la sesión del usuario es UTC. |
CASE Nota: BigQuery compara las marcas de tiempo en la zona horaria UTC. |
TIMESTAMPTZ_CMP_DATE( Nota: Redshift compara las marcas de tiempo en la zona horaria definida por la sesión de usuario. La zona horaria predeterminada de la sesión del usuario es UTC. |
CASE Nota: BigQuery compara las marcas de tiempo en la zona horaria UTC. |
TIMESTAMPTZ_CMP_TIMESTAMP(
Nota: Redshift compara las marcas de tiempo en la zona horaria definida por la sesión de usuario. La zona horaria predeterminada de la sesión del usuario es UTC. |
CASE Nota: BigQuery compara las marcas de tiempo en la zona horaria UTC. |
TIMEZONE( |
PARSE_TIMESTAMP( Nota: Las zonas horarias se usan cuando se analizan o se formatean las marcas de tiempo para fines de visualización. Una marca de tiempo con formato de string puede incluir una zona horaria, pero cuando BigQuery analiza la string, almacena la marca de tiempo en la hora UTC equivalente. Cuando una zona horaria no se especifica de forma explícita, se usa la zona horaria predeterminada, UTC. Se admiten nombres de zonas horarias o compensación de UTC (-HH:MM), pero no se admiten las abreviaturas de zona horaria (como PDT). |
TO_TIMESTAMP(timestamp,
format) |
PARSE_TIMESTAMP( Nota: BigQuery sigue un conjunto diferente de elementos de formato. Las zonas horarias se usan cuando se analizan o se formatean las marcas de tiempo para su visualización. Una marca de tiempo con formato de string puede incluir una zona horaria, pero cuando BigQuery analiza la string, almacena la marca de tiempo en la hora UTC equivalente. Cuando una zona horaria no se especifica de forma explícita, se usa la zona horaria predeterminada, UTC. Se admiten nombres de zonas horarias o compensación de UTC (-HH:MM) en la string de formato, pero no se admiten abreviaturas de zonas horarias (como PDT). |
TRUNC(timestamp) |
CAST(timestamp AS
DATE) |
BigQuery también ofrece las siguientes funciones de fecha y hora, que no tienen un análogo directo en Amazon Redshift:
EXTRACT
DATE
DATE_SUB
DATE_ADD
(muestra tipo de datosDATE
)DATE_FROM_UNIX_DATE
FORMAT_DATE
PARSE_DATE
UNIX_DATE
DATETIME
DATETIME_ADD
DATETIME_SUB
DATETIME_DIFF
DATETIME_TRUNC
FORMAT_DATETIME
PARSE_DATETIME
CURRENT_TIME
TIME
TIME_ADD
TIME_SUB
TIME_DIFF
TIME_TRUNC
FORMAT_TIME
PARSE_TIME
TIMESTAMP_SECONDS
TIMESTAMP_MILLIS
TIMESTAMP_MICROS
UNIX_SECONDS
UNIX_MILLIS
UNIX_MICROS
Operadores matemáticos
En la siguiente tabla, se muestran las asignaciones entre operadores matemáticos comunes de Amazon Redshift con sus equivalentes de BigQuery.
Amazon Redshift | BigQuery |
---|---|
|
|
|
|
|
|
Nota: Si el operador realiza división de números enteros (en otras palabras, si X y Y son números enteros), se muestra un número entero. Si el operador realiza una división de números no enteros, se muestra un número no entero. |
Si la división del número entero es la siguiente: CAST(FLOOR(X / Y) AS INT64)
Si no es una división de números enteros, haz lo siguiente:
Nota: La división en BigQuery muestra un número no entero. Para evitar errores de una operación de división (división por error de cero), usa SAFE_DIVIDE(X, Y) o IEEE_DIVIDE(X, Y) . |
|
Nota: Para evitar errores de una operación de división (división por cero error), usa SAFE.MOD(X, Y) . Resultados de SAFE.MOD(X, 0) en 0. |
|
Nota: A diferencia de Amazon Redshift, el operador ^ en BigQuery realiza un proceso a nivel de bits. |
|
Nota: Para evitar errores de una operación raíz cuadrada (entrada negativa), usa SAFE.SQRT(X) . La entrada negativa con SAFE.SQRT(X) da como resultado NULL . |
|
Nota: POWER(X, Y) de BigQuery muestra un error si X es un valor finito menor que 0 y Y es un número no entero. |
|
|
|
Nota: Este operador muestra 0 o una secuencia de bytes de b'\x00' si el segundo operando Y es igual o mayor que el largo de bits del primer operando X (por ejemplo, 64 si X tiene el tipo INT64). Este operador muestra un error si Y es negativo. |
|
Nota: Desplaza el primer operando X a la derecha. Este operador no realiza la extensión de signo con un tipo de signo (llena los bits vacantes de la izquierda con 0). Este operador muestra 0 o una secuencia de bytes de b'\x00' si el segundo operando Y es igual o mayor que el largo de bits del primer operando X (por ejemplo, 64 si X tiene el tipo INT64). Este operador muestra un error si Y es negativo. |
|
|
|
|
|
|
BigQuery también ofrece el siguiente operador matemático, que no tiene un análogo directo en Amazon Redshift:
X ^ Y
(XOR a nivel de bits)
Funciones matemáticas
Amazon Redshift | BigQuery |
---|---|
ABS(number) |
ABS(number) |
ACOS(number) |
ACOS(number) |
ASIN(number) |
ASIN(number) |
ATAN(number) |
ATAN(number) |
ATAN2(number1,
number2) |
ATAN2(number1,
number2) |
CBRT(number) |
POWER(number, 1/3) |
CEIL(number) |
CEIL(number) |
CEILING(number) |
CEILING(number) |
CHECKSUM(expression) |
FARM_FINGERPRINT(expression)
|
COS(number) |
COS(number) |
COT(number) |
1/TAN(number) |
DEGREES(number) |
number *180/ACOS(-1) |
DEXP(number) |
EXP(number) |
DLOG1(number) |
LN(number) |
DLOG10(number) |
LOG10(number) |
EXP(number) |
EXP(number) |
FLOOR(number) |
FLOOR(number) |
LNnumber) |
LN(number) |
LOG(number) |
LOG10(number) |
MOD(number1, number2) |
MOD(number1, number2) |
PI |
ACOS(-1) |
POWER(expression1,
expression2) |
POWER(expression1,
expression2) |
RADIANS(number) |
ACOS(-1)*(number/180) |
RANDOM() |
RAND() |
ROUND(number [,
integer]) |
ROUND(number [,
integer]) |
SIN(number) |
SIN(number) |
SIGN(number) |
SIGN(number) |
SQRT(number) |
SQRT(number) |
TAN(number) |
TAN(number) |
TO_HEX(number) |
FORMAT('%x', number) |
TRUNC(number [,
integer])+-+++ |
TRUNC(number [, integer])
|
Funciones de string
Amazon Redshift | BigQuery |
---|---|
string1 || string2 |
CONCAT(string1,
string2) |
BPCHARCMP(string1,
string2) |
CASE |
BTRIM(string [,
matching_string]) |
TRIM(string [,
matching_string]) |
BTTEXT_PATTERN_CMP(string1,
string2) |
CASE |
CHAR_LENGTH(expression) |
CHAR_LENGTH(expression) |
CHARACTER_LENGTH(expression) |
CHARACTER_LENGTH(expression) |
CHARINDEX(substring,
string) |
STRPOS(string, substring)
|
CHR(number) |
CODE_POINTS_TO_STRING([number])
|
CONCAT(string1,
string2) |
CONCAT(string1,
string2) Nota: CONCAT (…) de BigQuery admite que concatena cualquier cantidad de strings. |
CRC32 |
Función personalizada definida por el usuario |
FUNC_SHA1(string) |
SHA1(string) |
INITCAP |
INITCAP |
LEFT(string, integer) |
SUBSTR(string, 0, integer)
|
RIGHT(string, integer)
|
SUBSTR(string,
-integer) |
LEN(expression) |
LENGTH(expression) |
LENGTH(expression) |
LENGTH(expression) |
LOWER(string) |
LOWER(string) |
LPAD(string1, length[,
string2]) |
LPAD(string1, length[,
string2]) |
RPAD(string1, length[,
string2]) |
RPAD(string1, length[,
string2]) |
LTRIM(string,
trim_chars) |
LTRIM(string,
trim_chars) |
MD5(string) |
MD5(string) |
OCTET_LENGTH(expression) |
BYTE_LENGTH(expression) |
POSITION(substring IN
string) |
STRPOS(string,
substring) |
QUOTE_IDENT(string) |
CONCAT('"',string,'"') |
QUOTE_LITERAL(string) |
CONCAT("'",string,"'")
|
REGEXP_COUNT(
source_string, pattern |
ARRAY_LENGTH( REGEXP_EXTRACT_ALL( Si se especifica position : ARRAY_LENGTH( REGEXP_EXTRACT_ALL( Nota: BigQuery proporciona compatibilidad con expresiones regulares mediante la biblioteca re2 . Consulta esa documentación para conocer su sintaxis de expresión regular. |
REGEXP_INSTR( |
IFNULL( STRPOS( Si se especifica source_string : REGEXP_REPLACE( Si se especifica position :IFNULL( STRPOS( Si se especifica occurrence :IFNULL( STRPOS( Nota: BigQuery proporciona compatibilidad con expresiones regulares mediante la biblioteca re2 .
Consulta esa documentaciónpara conocer su sintaxis de expresión regular. |
REGEXP_REPLACE(
source_string, |
REGEXP_REPLACE( Si se especifica source_string :
REGEXP_REPLACE( Si se especifica position :CASE |
REGEXP_SUBSTR(
source_string, pattern |
REGEXP_EXTRACT( Si se especifica position :REGEXP_EXTRACT( Si se especifica occurrence :REGEXP_EXTRACT_ALL( Nota: BigQuery proporciona compatibilidad con expresiones regulares mediante la biblioteca re2 . Consulta esa documentación para conocer su sintaxis de expresión regular.
|
REPEAT(string,
integer) |
REPEAT(string,
integer) |
REPLACE(string, old_chars,
new_chars) |
REPLACE(string, old_chars,
new_chars) |
REPLICA(string,
integer) |
REPEAT(string,
integer) |
REVERSE(expression) |
REVERSE(expression) |
RTRIM(string,
trim_chars) |
RTRIM(string,
trim_chars) |
SPLIT_PART(string,
delimiter, part) |
SPLIT( |
STRPOS(string,
substring) |
STRPOS(string,
substring) |
STRTOL(string, base) |
|
SUBSTRING( |
SUBSTR( |
TEXTLEN(expression) |
LENGTH(expression) |
TRANSLATE( |
Se puede implementar mediante UDF: CREATE TEMP FUNCTION |
TRIM([BOTH] string) |
TRIM(string) |
TRIM([BOTH] characters FROM
string) |
TRIM(string, characters)
|
UPPER(string) |
UPPER(string) |
Funciones de formato de tipo de datos
Amazon Redshift | BigQuery |
---|---|
CAST(expression AS type) |
CAST(expression AS type) |
expression ::
type |
CAST(expression AS type) |
CONVERT(type, expression) |
CAST(expression AS type) |
TO_CHAR(
|
FORMAT_TIMESTAMP( Nota: BigQuery y Amazon Redshift difieren en cómo especificar una string de formato para timestamp_expression . |
TO_CHAR(
|
FORMAT( Nota: BigQuery y Amazon Redshift difieren en cómo especificar una string de formato para timestamp_expression .
|
TO_DATE(date_string, format) |
PARSE_DATE(date_string, format)
Nota: BigQuery y Amazon Redshift difieren en cómo especificar una string de formato para date_string . |
TO_NUMBER(string, format) |
CAST( Nota: BigQuery y Amazon Redshift difieren en cómo especificar una string de formato numérico. |
BigQuery también admite SAFE_CAST
(expression
AS typename)
, que muestra NULL
si BigQuery no puede realizar una conversión de tipos, por ejemplo, SAFE_CAST
("apple"
AS INT64)
muestra NULL
.
Sintaxis de DML
En esta sección, se abordan las diferencias que existen entre la sintaxis del lenguaje de administración de datos de Amazon Redshift y BigQuery.
Declaración INSERT
Amazon Redshift ofrece una palabra clave DEFAULT
configurable para las columnas. En BigQuery, el valor DEFAULT
para las columnas que permiten valores nulos es NULL
, y DEFAULT
no es compatible con las columnas obligatorias. La mayoría de las declaraciones INSERT
de Amazon Redshift son compatibles con BigQuery. En la siguiente tabla, se muestran las excepciones.
Amazon Redshift | BigQuery |
---|---|
INSERT INTO table (column1 [, ...]) |
INSERT [INTO] table (column1 [, ...]) |
INSERT INTO table (column1, [,...]) VALUES ( |
INSERT [INTO] table (column1, [,...]) |
BigQuery también admite la inserción de valores mediante una subconsulta (en la que uno de los valores se calcula mediante una subconsulta), lo cual no es compatible con Amazon Redshift. Por ejemplo:
INSERT INTO table (column1, column2)
VALUES ('value_1', (
SELECT column2
FROM table2
))
Declaración COPY
El comando COPY
de Amazon Redshift carga datos en una tabla desde archivos de datos o desde una tabla de Amazon DynamoDB.
BigQuery no usa el comando SQL COPY
para cargar datos, pero puedes usar cualquiera de las herramientas y opciones distintas de SQL para cargar datos en tablas de BigQuery.
También puedes usar receptores de canalización de datos proporcionados en Apache Spark o Apache Beam para escribir datos en BigQuery.
Declaración UPDATE
La mayoría de las declaraciones UPDATE
de Amazon Redshift son compatibles con BigQuery. En la siguiente tabla, se muestran las excepciones.
Amazon Redshift | BigQuery |
---|---|
UPDATE table |
UPDATE table Nota: Todas las declaraciones UPDATE en BigQuery requieren una palabra clave WHERE , seguida de una condición. |
UPDATE table |
UPDATE table Nota: El comando UPDATE de BigQuery no admite valores DEFAULT .
Si la declaración UPDATE de Amazon Redshift no incluye una cláusula WHERE , la declaración UPDATE de BigQuery debe estar condicionada a WHERE TRUE . |
Declaraciones DELETE
y TRUNCATE
Las declaraciones DELETE
y TRUNCATE
son alternativas para quitar filas de una tabla sin afectar el esquema ni los índices de esta.
En Amazon Redshift, la declaración TRUNCATE
se recomienda en lugar de una declaración DELETE
no calificada porque es más rápida y no requiere operaciones VACUUM
y ANALYZE
después.
Sin embargo, puedes usar declaraciones DELETE
para obtener el mismo resultado.
En BigQuery, la declaración DELETE
debe tener una cláusula WHERE
. Para obtener más información sobre DELETE
en BigQuery, consulta los ejemplos de DELETE
de BigQuery en la documentación del DML.
Amazon Redshift | BigQuery |
---|---|
DELETE
[FROM] table_name TRUNCATE
[TABLE] table_name |
DELETE FROM table_name Las declaraciones DELETE de BigQuery requieren una cláusula WHERE . |
DELETE FROM table_name |
DELETE FROM table_name DELETE FROM table_name En Amazon Redshift, USING permite que se haga referencia a tablas adicionales en la cláusula WHERE . Esto se puede lograr en BigQuery mediante una subconsulta en la cláusula WHERE . |
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 de forma atómica. La operación MERGE
debe vincular como máximo una fila de origen con cada fila de destino.
Amazon Redshift no admite un comando único de MERGE
. Sin embargo, se puede realizar una operación de combinación en Amazon Redshift mediante las operaciones INSERT
, UPDATE
y DELETE
en una transacción.
Combinar operación para reemplazar filas existentes
En Amazon Redshift, un reemplazo de todas las columnas de la tabla de destino se puede realizar mediante una declaración DELETE
y, luego, una INSERT
. La declaración DELETE
quita las filas que se deben actualizar y, luego, la declaración INSERT
inserta las filas actualizadas. Las tablas de BigQuery se limitan a 1,000 declaraciones DML por día, por lo que debes consolidar las declaraciones INSERT
, UPDATE
y DELETE
en una sola MERGE
como se muestra en la siguiente tabla.
Amazon Redshift | BigQuery |
---|---|
Consulta Realiza una operación de combinación mediante el reemplazo de las filas existentes. CREATE TEMP TABLE temp_table; |
MERGE target Nota: Todas las columnas se deben enumerar si se actualizan todas. |
Consulta Realiza una operación de combinación mediante la especificación de una lista de columnas. CREATE TEMP TABLE temp_table; |
MERGE target |
Sintaxis del DDL
En esta sección, se abordan las diferencias que existen entre la sintaxis del lenguaje de definición de datos en Amazon Redshift y BigQuery.
Declaración SELECT INTO
En Amazon Redshift, la declaración SELECT INTO
se puede usar para insertar los resultados de una consulta en una tabla nueva, y se combina la creación y la inserción de tablas.
Amazon Redshift | BigQuery |
---|---|
SELECT expression, ... INTO table |
INSERT table |
WITH subquery_table AS ( SELECT ... |
INSERT table |
SELECT expression |
BigQuery ofrece varias formas de emular tablas temporales. Consulta la sección tablas temporales para obtener más información. |
Declaración CREATE TABLE
La mayoría de las declaraciones CREATE TABLE
de Amazon Redshift son compatibles con BigQuery, excepto los siguientes elementos de la sintaxis, que no se usan en BigQuery:
Amazon Redshift | BigQuery |
---|---|
CREATE TABLE table_name ( Nota: UNIQUE yPRIMARY KEY las restricciones son informativas y no las aplica el sistema Amazon Redshift no aplica. |
CREATE TABLE table_name ( |
CREATE TABLE table_name Nota: Las restricciones UNIQUE y PRIMARY KEY son informativas y no las aplica el sistema de Amazon Redshift.
|
CREATE TABLE table_name Nota: BigQuery no usa restricciones de tabla UNIQUE , PRIMARY KEY o FOREIGN KEY . Para lograr una optimización similar que estas restricciones proporcionan durante la ejecución de la consulta, particiona y agrupa en clústeres tus tablas de BigQuery. CLUSTER BY admite hasta 4 columnas. |
CREATE TABLE table_name |
Consulta este ejemplo para aprender a usar las tablas INFORMATION_SCHEMA a fin de copiar nombres de columnas, tipos de datos y restricciones NOT NULL en una tabla nueva. |
CREATE TABLE table_name Nota: En Amazon Redshift, la configuración BACKUP
NO se especifica para ahorrar tiempo de procesamiento y reducir el espacio de almacenamiento. |
La opción BACKUP NO no se usa ni es necesaria, ya que BigQuery conserva de manera automática hasta 7 días de versiones históricas de todas las tablas sin afectar el tiempo de procesamiento ni el almacenamiento facturado.
|
CREATE TABLE table_name |
BigQuery es compatible con el agrupamiento en clústeres, lo que permite almacenar claves en orden. |
CREATE TABLE table_name |
CREATE TABLE table_name |
CREATE TABLE IF NOT EXISTS table_name ... |
CREATE TABLE IF NOT EXISTS |
BigQuery también admite la declaración DDL CREATE OR REPLACE TABLE
, que reemplaza una tabla si ya existe.
La declaración CREATE TABLE
de BigQuery también admite las siguientes cláusulas, que no tienen un equivalente de Amazon Redshift:
Para obtener más información sobre CREATE TABLE
en BigQuery, consulta los ejemplos de CREATE TABLE
de BigQuery en la documentación del DML.
Tablas temporales
Amazon Redshift admite tablas temporales, que solo son visibles dentro de la sesión actual. Existen varias formas de emular tablas temporales en BigQuery, entre las que se encuentran las siguientes:
- TTL del conjunto de datos: Crea un conjunto de datos con un tiempo de actividad corto (por ejemplo, 1 hora) para que las tablas creadas en el conjunto de datos sean temporales, ya que no durarán más que el tiempo de actividad del conjunto de datos. Puedes poner prefijos en todos los nombres de las tablas de este conjunto de datos mediante para indicar con claridad que las tablas son temporales.
TTL de la tabla: Crea una tabla que tenga un tiempo de actividad específico para la tabla mediante declaraciones del DDL similares a las siguientes:
CREATE TABLE temp.name (col1, col2, ...) OPTIONS (expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR));
Declaración CREATE VIEW
En la siguiente tabla, se muestran equivalencias de la declaración CREATE VIEW
entre Amazon Redshift y BigQuery.
Amazon Redshift | BigQuery |
---|---|
CREATE VIEW view_name AS SELECT ... code> |
CREATE VIEW view_name AS SELECT
... |
CREATE OR REPLACE VIEW view_name AS SELECT ... |
CREATE OR REPLACE VIEW |
CREATE VIEW view_name |
CREATE VIEW view_name AS SELECT
... |
No compatible. | CREATE VIEW IF NOT EXISTS c
view_name Crea una vista nueva solo si la vista no existe en el conjunto de datos especificado. |
CREATE VIEW view_name En Amazon Redshift, se requiere una vista de vinculación tardía para hacer referencia a una tabla externa. |
En BigQuery, para crear una vista, todos los objetos a los que se hace referencia ya deben existir. BigQuery te permite consultar fuentes de datos externas. |
Funciones definidas por el usuario (UDF)
Una UDF te permite crear funciones para operaciones personalizadas. Estas funciones aceptan columnas de entrada, realizan acciones y muestran el resultado de esas acciones como un valor.
Amazon Redshift y BigQuery admiten las UDF mediante expresiones de SQL. Además, en Amazon Redshift, puedes crear unUDF basada en Python y, en BigQuery, puedes crear unUDF basada en JavaScript.
Consulta el repositorio de GitHub de utilidades de BigQuery de Google Cloud para obtener una biblioteca de UDF comunes de BigQuery.
Sintaxis de CREATE FUNCTION
En la siguiente tabla, se abordan las diferencias que existen en la sintaxis de creación de UDF de SQL entre Amazon Redshift y BigQuery.
Amazon Redshift | BigQuery |
---|---|
CREATE [OR
REPLACE] FUNCTION |
CREATE [OR REPLACE] FUNCTION Nota: En una UDF de SQL de BigQuery, el tipo de datos que se muestra es opcional. BigQuery infiere el tipo de resultado de la función a partir del cuerpo de la función SQL cuando una consulta llama a la función. |
CREATE [OR
REPLACE] FUNCTION |
CREATE [OR REPLACE] FUNCTION Nota: La volatilidad de la función no es un parámetro configurable en BigQuery. Toda la volatilidad de la UDF de BigQuery es equivalente a la volatilidad IMMUTABLE de Amazon Redshift (es decir, no realiza búsquedas en bases de datos ni usa información que no está directamente presente en su lista de argumentos).
|
CREATE [OR
REPLACE] FUNCTION Nota: Amazon Redshift solo admite una cláusula SQL SELECT como definición de función. Además, la cláusula SELECT no puede incluir ninguna cláusula FROM,
INTO, WHERE, GROUP BY, ORDER BY, y LIMIT . |
CREATE [OR REPLACE] FUNCTION Nota: BigQuery admite cualquier expresión de SQL como definición de función. Sin embargo, no se admite la referencia a tablas, vistas o modelos. |
CREATE [OR
REPLACE] FUNCTION |
CREATE [OR REPLACE] FUNCTION
function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS
data_type AS sql_function_definition Nota: No es necesario especificar un literal de lenguaje en una UDF de GoogleSQL. BigQuery interpreta la expresión SQL de forma predeterminada. Además, la cotización en dólares de Amazon Redshift ( $$ ) no es compatible con BigQuery. |
CREATE [OR
REPLACE] FUNCTION function_name (integer, integer) RETURNS
integer IMMUTABLE AS $$ SELECT $1 + $2 $$ LANGUAGE sql |
CREATE [OR REPLACE] FUNCTION Nota: Las UDF de BigQuery requieren que se nombren todos los argumentos de entrada. Las variables de argumento de Amazon Redshift ( $1 , $2 , …) no son compatibles con BigQuery. |
CREATE [OR
REPLACE] FUNCTION Nota: Amazon Redshift no es compatible con ANY TYPE para las UDF de SQL. Sin embargo, es compatible con el tipo de datos ANYELEMENT en las UDF basadas en Python. |
CREATE [OR REPLACE] FUNCTION Nota: BigQuery admite el uso de ANY TYPE como tipo de argumento. La función acepta una entrada de cualquier tipo para este argumento. Para obtener más información, consulta Parámetro con plantilla en BigQuery.
|
BigQuery también admite la declaración CREATE FUNCTION IF NOT EXISTS
, que trata la consulta como correcta y no realiza ninguna acción si ya existe una función con el mismo nombre.
La declaración CREATE FUNCTION
de BigQuery también admite la creación de funciones TEMPORARY
o TEMP
, que no tienen un equivalente de Amazon Redshift.
Consulta cómo llamar a las UDF para obtener detalles sobre cómo ejecutar una UDF persistente de BigQuery.
Sintaxis de DROP FUNCTION
En la siguiente tabla, se abordan las diferencias que existen en la sintaxis de DROP FUNCTION
entre Amazon Redshift y BigQuery.
Amazon Redshift | BigQuery |
---|---|
DROP
FUNCTION |
DROP FUNCTION Nota: BigQuery no requiere el uso de la firma de la función para borrar la función. Además, quitar dependencias de funciones no es compatible con BigQuery. |
BigQuery también admite la declaración DROP FUNCTION IF EXISTS
, que borra la función solo si existe en el conjunto de datos especificado.
BigQuery requiere que especifiques el project_name si la función no se encuentra en el proyecto actual.
Componentes de UDF
En esta sección, se destacan las similitudes y diferencias en los componentes de la UDF entre Amazon Redshift y BigQuery.
Componente | Amazon Redshift | BigQuery |
---|---|---|
Nombre | Amazon Redshift recomienda usar el prefijo _f para los nombres de las funciones a fin de evitar conflictos con los nombres de funciones de SQL integradas existentes o futuras. |
En BigQuery, puedes usar cualquier nombre de función personalizado. |
Argumentos | Los argumentos son opcionales. Puedes usar tipos de datos y nombres para argumentos de UDF de Python y solo tipos de datos para argumentos de UDF de SQL. En las UDF de SQL, debes hacer referencia a los argumentos mediante $1 , $2 , etcétera. Amazon Redshift también restringe la cantidad de argumentos a 32. |
Los argumentos son opcionales, pero si especificas argumentos, deben usar nombres y tipos de datos para las UDF de JavaScript y SQL. El número máximo de argumentos para una UDF persistente es de 256. |
Tipo de datos | Amazon Redshift admite un conjunto diferente de tipos de datos para UDF de SQL y Python. Para una UDF de Python, el tipo de datos también puede ser ANYELEMENT .Debes especificar un tipo de datos RETURN para las UDF de SQL y Python.Consulta Tipos de datos en este documento para conocer los equivalentes entre los tipos de datos en Amazon Redshift y en BigQuery. |
BigQuery es compatible con un conjunto diferente de tipos de datos para UDF de SQL y JavaScript. Para una UDF de SQL, el tipo de datos también puede ser ANY TYPE . Para obtener más información, consulta parámetros con plantilla en BigQuery.El tipo de datos RETURN es opcional para las UDF de SQL.Consulta las Codificaciones de tipos de SQL en JavaScript para obtener información sobre cómo los tipos de datos de BigQuery se corresponden con los tipos de JavaScript. |
Definición | Para las UDF de SQL y Python, debes encerrar la definición de la función mediante comillas de dólares, como en un par de signos de dólares ($$ ), para indicar el inicio y el final de las declaraciones de funciones.Para la UDF de SQL, Amazon Redshift solo admite una cláusula SELECT de SQL como definición de la función. Además, la cláusula SELECT no puede incluir ninguna de las FROM , INTO , WHERE , GROUP BY ORDER BY y LIMIT
.Para las UDF de Python, puedes escribir un programa de Python mediante la biblioteca estándar de Python 2.7. También puedes importar tus módulos personalizados mediante la creación de uno mediante el comando CREATE
LIBRARY . |
En BigQuery, debes encerrar el código de JavaScript entre comillas. Consulta Reglas de uso de comillas para obtener más información. Para las UDF de SQL, puedes usar cualquier expresión de SQL como la definición de la función. Sin embargo, BigQuery no admite la referencia a tablas, vistas ni modelos. Para las UDF de JavaScript, puedes incluir bibliotecas de código externas directamente mediante la sección OPTIONS . También puedes usar la herramienta de prueba de UDF de BigQuery para probar tus funciones. |
Lenguaje | Debes usar el literal LANGUAGE a fin de especificar el lenguaje como sql para las UDF de SQL o plpythonu
para las UDF de Python. |
No es necesario que especifiques LANGUAGE para las UDF de SQL, pero debes especificar el lenguaje como js para las UDF de JavaScript. |
Estado | Amazon Redshift no admite la creación de UDF temporales. Amazon Redshift proporciona una opción para definir la volatilidad de una función mediante literales VOLATILE , STABLE o IMMUTABLE . El optimizador de consultas lo usa para la optimización. |
BigQuery admite UDF persistentes y temporales. Puedes reutilizar las UDF persistentes en varias consultas, mientras que solo puedes usar las UDF temporales en una única consulta. Nota: La volatilidad de la función no es un parámetro configurable en BigQuery. Toda la volatilidad de la UDF de BigQuery es equivalente a la volatilidad IMMUTABLE
de Amazon Redshift. |
Seguridad y privilegios | Si deseas crear una UDF, debes tener permiso para el uso en el lenguaje para SQL o plpythonu (Python). De forma predeterminada, USAGE ON LANGUAGE SQL se otorga a PUBLIC , pero debes otorgar de forma explícita USAGE ON LANGUAGE PLPYTHONU
a usuarios o grupos específicos.Además, debes ser un superusuario para reemplazar una UDF. |
No es necesario otorgar permisos explícitos para crear o borrar cualquier tipo de UDF en BigQuery. Cualquier usuario al que se le asignó el rol BigQuery Data Editor (con bigquery.routines.* como uno de los permisos) puede crear o borrar funciones para el conjunto de datos especificado.BigQuery también admite la creación de roles personalizados. Esto se puede administrar mediante Cloud IAM. |
Límites | Consulta los límites de UDF de Python. | Consulta los límites de UDF. |
Instrucciones de SQL de transacciones y metadatos
Amazon Redshift | BigQuery |
---|---|
SELECT * FROM STL_ANALYZE WHERE name |
No se usa en BigQuery. No es necesario recopilar estadísticas para mejorar el rendimiento de las consultas. Para obtener información sobre tu distribución de datos, puedes usar las funciones de agregación aproximadas. |
ANALYZE
[[ table_name[(column_name |
No se usa en BigQuery. |
LOCK
TABLE table_name; |
No se usa en BigQuery. |
BEGIN
TRANSACTION; SELECT ... |
BigQuery usa el aislamiento de instantáneas. Para obtener más información, consulta Garantías de coherencia. |
EXPLAIN
... |
No se usa en BigQuery. Las funciones similares son la explicación del plan de consultas en BigQuery de la consola de Google Cloud y en el registro de auditoría en Cloud Monitoring. |
SELECT * FROM SVV_TABLE_INFO WHERE |
SELECT * EXCEPT(is_typed) FROM Para obtener más información, consulta Introducción a BigQuery INFORMATION_SCHEMA . |
VACUUM
[table_name] |
No se usa en BigQuery. Las tablas agrupadas en clústeres de BigQuery se ordenan automáticamente. |
Instrucciones de SQL de varias instrucciones y varias líneas
Amazon Redshift y BigQuery admiten transacciones (sesiones) y, por lo tanto, admiten declaraciones separadas por punto y coma que se ejecutan juntas de manera coherente. Para obtener más información, consulta Transacciones de varias declaraciones.
Instrucciones de SQL de procedimiento
Declaración CREATE PROCEDURE
Amazon Redshift | BigQuery |
---|---|
CREATE or
REPLACE PROCEDURE |
Usa CREATE PROCEDURE si se requiere un nombre.De lo contrario, úsalo intercalado con BEGIN o en una sola línea con CREATE TEMP FUNCTION . |
CALL |
CALL |
Declaración y asignación de variables
Amazon Redshift | BigQuery |
---|---|
DECLARE |
DECLARE Declara una variable del tipo especificado. |
SET |
SET Establece una variable para tener el valor de la expresión proporcionada, o establece muchas variables al mismo tiempo en función del resultado de varias expresiones. |
Controladores de condiciones de error
En Amazon Redshift, un error que se produce durante la ejecución de un procedimiento almacenado finaliza el flujo de ejecución, finaliza la transacción y revierte la transacción.
Estos resultados se producen porque no se admiten las transacciones secundarias. En un procedimiento almacenado en Amazon Redshift, el único handler_statement
admitido es RAISE
. En BigQuery, el control de errores es una función principal del flujo de control principal, similar a lo que proporcionan otros lenguajes con bloques TRY ... CATCH
.
Amazon Redshift | BigQuery |
---|---|
BEGIN ...
EXCEPTION WHEN OTHERS THEN |
BEGIN ... EXCEPTION WHEN ERROR
THEN |
RAISE |
RAISE |
[ <<label>> ] [ DECLARE declarations ] |
BEGIN |
Declaraciones y operaciones del cursor
Debido a que BigQuery no admite cursores ni sesiones, las siguientes declaraciones no se usan en BigQuery:
DECLARE
cursor_name
CURSOR
[FOR] ...
PREPARE
plan_name [ (datatype [, ...] ) ] AS statement
OPEN
cursor_name FOR SELECT ...
FETCH
[ NEXT | ALL | {FORWARD [ count | ALL ] } ] FROM cursor_name
CLOSE
cursor_name;
Si usas el cursor para mostrar un conjunto de resultados, puedes lograr un comportamiento similar con las tablas temporales en BigQuery.
Instrucciones de SQL dinámicas
La función de secuencia de comandos en BigQuery admite instrucciones de SQL dinámicas como las que se muestran en la siguiente tabla.
Amazon Redshift | BigQuery |
---|---|
EXECUTE |
EXECUTE IMMEDIATE |
Instrucciones de flujo de control
Amazon Redshift | BigQuery |
---|---|
IF..THEN..ELSIF..THEN..ELSE..END
IF |
IF condition |
name CURSOR
[ ( arguments ) ] FOR query |
Los cursores o las sesiones no se usan en BigQuery. |
[< |
LOOP |
WHILE
condition LOOP stmts END LOOP |
WHILE condition |
EXIT |
BREAK |
Garantías de coherencia y aislamiento de transacción
Tanto Amazon Redshift como BigQuery son atómicos, es decir, cumplen con el estándar ACID en un nivel por transformación en muchas filas.
Transacciones
Amazon Redshift admite el aislamiento serializable de forma predeterminada para las transacciones. Amazon Redshift te permite especificar cualquiera de los cuatro niveles de aislamiento de transacción estándar de SQL, pero procesa todos los niveles de aislamiento como serializables.
BigQuery también admite transacciones. BigQuery ayuda a garantizar el 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 por fila, por transformación y entre filas dentro de la misma declaración DML y evita los interbloqueos. En el caso de varias actualizaciones de DML en la misma tabla, BigQuery cambia al control de simultaneidad pesimista. Los trabajos de carga pueden ejecutarse de forma independiente por completo y agregarse a las tablas.
Revertir
Si Amazon Redshift encuentra algún error mientras ejecuta un procedimiento almacenado, revierte todos los cambios realizados en una transacción. Además, puedes usar la declaración de control de transacción ROLLBACK
en un procedimiento almacenado para descartar todos los cambios.
En BigQuery, puedes usar la sentencia ROLLBACK TRANSACTION
.
Límites de bases de datos
Siempre consulta la documentación pública de BigQuery para conocer las cuotas y los límites actuales. Para aumentar las cuotas de los usuarios de gran volumen, comunícate con el equipo de Asistencia de Cloud. En la siguiente tabla, se muestra una comparación de los límites de bases de datos de Amazon Redshift y BigQuery.
Límite | Amazon Redshift | BigQuery |
---|---|---|
Tablas en cada base de datos para tipos de nodos de clúster grandes y muy grandes | 9,900 | Sin restricciones |
Tablas en cada base de datos para tipos de nodos de clúster 8xlarge | 20,000 | Sin restricciones |
Bases de datos definidas por el usuario que puedes crear para cada clúster | 60 | Sin restricciones |
Tamaño máximo de fila | 4 MB | 100 MB |