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

INT, INT4

 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

FLOAT8, FLOAT

 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

CHARACTER, NCHAR, BPCHAR

STRING
VARCHAR

CHARACTER VARYING, NVARCHAR, TEXT

STRING
DATE DATE
TIMESTAMP TIMESTAMP WITHOUT TIME ZONE DATETIME
TIMESTAMPTZ

TIMESTAMP WITH TIME ZONE

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

INT64

FLOAT64

INT64

NUMERIC

NUMERIC

FLOAT64

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”)

DATE

Literal de STRING
(p. ej., “2008-12-25 15:30:00”)

TIMESTAMP

Literal de STRING
(p.ej., “2008-12-25T07:30:00”)

DATETIME

Literal de STRING
(p.ej., “15:30:00”)

TIME

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

SELECT TOP number expression
FROM table

SELECT expression
FROM table
ORDER BY expression DESC
LIMIT number

SELECT
x/total AS probability,
ROUND(100 * probability, 1) AS pct
FROM raw_data

Nota: Redshift admite la creación y referencia de un alias en la misma declaración SELECT.

SELECT
x/total AS probability,
ROUND(100 * (x/total), 1) AS pct
FROM raw_data

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:

JOIN tipos

Amazon Redshift y BigQuery admiten los siguientes tipos de unión:

En la siguiente tabla, se incluye una lista de diferencias menores.

Amazon Redshift BigQuery

SELECT col
FROM table1
NATURAL INNER JOIN
table2

SELECT col1
FROM table1
INNER JOIN
table2
USING (col1, col2 [, ...])


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

SELECT * FROM table1
UNION
SELECT * FROM table2

SELECT * FROM table1
UNION DISTINCT
SELECT * FROM table2

Nota: BigQuery y Amazon Redshift admiten el operador UNION ALL.

SELECT * FROM table1
INTERSECT
SELECT * FROM table2

SELECT * FROM table1
INTERSECT DISTINCT
SELECT * FROM table2

SELECT * FROM table1
EXCEPT
SELECT * FROM table2

SELECT * FROM table1
EXCEPT DISTINCT
SELECT * FROM table2

SELECT * FROM table1
MINUS
SELECT * FROM table2

SELECT * FROM table1
EXCEPT DISTINCT
SELECT * FROM table2

SELECT * FROM table1
UNION
SELECT * FROM table2
EXCEPT
SELECT * FROM table3

SELECT * FROM table1
UNION ALL
(
SELECT * FROM table2
EXCEPT
SELECT * FROM table3
)


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

SELECT *
FROM table
ORDER BY expression
LIMIT ALL

SELECT *
FROM table
ORDER BY expression



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.

SELECT *
FROM table
ORDER BY expression
OFFSET 10

SELECT *
FROM table
ORDER BY expression
LIMIT count OFFSET 10



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

a = ANY (subquery)

a = SOME (subquery)

a IN subquery

a <> ALL (subquery)

a != ALL (subquery)

a NOT IN subquery

a IS UNKNOWN

expression ILIKE pattern

a IS NULL

LOWER(expression) LIKE LOWER(pattern)

expression LIKE pattern ESCAPE 'escape_char'

expression LIKE pattern


Nota: BigQuery no admite caracteres de escape personalizados. Debes usar dos barras invertidas (“\\”) como caracteres de escape para BigQuery.

expression [NOT] SIMILAR TO pattern

IF(
LENGTH(
REGEXP_REPLACE(
expression,
pattern,
''
) = 0,
True,
False
)


Nota: Si se especifica NOT, encierra la expresión IF anterior en una expresión NOT como se muestra a continuación:

NOT(
IF(
LENGTH(...
)

expression [!] ~ pattern

[NOT] REGEXP_CONTAINS(
expression,
regex
)

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(
percentile
) WITHIN GROUP (ORDER BY expression)		 APPROX_QUANTILES(expression, 100)
[OFFSET(CAST(TRUNC(percentile * 100) as INT64))]
AVG([DISTINCT] expression) AVG([DISTINCT] expression)
COUNT(expression) COUNT(expression)
LISTAGG(
[DISTINCT] aggregate_expression
[, delimiter] )
[WITHIN GROUP (ORDER BY order_list)] 		STRING_AGG(
[DISTINCT] aggregate_expression
[, delimiter]
[ORDER BY order_list] )
MAX(expression) MAX(expression)
MEDIAN(median_expression) PERCENTILE_CONT( median_expression, 0.5 ) OVER()
MIN(expression) MIN(expression)
PERCENTILE_CONT(
percentile
) WITHIN GROUP (ORDER BY expression)		 PERCENTILE_CONT(
median_expression,
percentile
) OVER()

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:

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
(
[PARTITION BY expr_list]
[ORDER BY order_list frame_clause]
)		 AVG(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
COUNT(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 COUNT(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
CUME_DIST() OVER
(
[PARTITION BY partition_expression]
[ORDER BY order_list]
) 		CUME_DIST() OVER
(
[PARTITION BY partition_expression]
ORDER BY order_list
)
DENSE_RANK() OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
) 		DENSE_RANK() OVER
(
[PARTITION BY expr_list]
ORDER BY order_list
)
FIRST_VALUE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 FIRST_VALUE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
LAST_VALUE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 LAST_VALUE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)
LAG(value_expr [, offset]) OVER
(
[PARTITION BY window_partition]
ORDER BY window_ordering
) 		LAG(value_expr [, offset]) OVER
(
[PARTITION BY window_partition]
ORDER BY window_ordering
)
LEAD(value_expr [, offset]) OVER
(
[PARTITION BY window_partition]
ORDER BY window_ordering
) 		LEAD(value_expr [, offset]) OVER
(
[PARTITION BY window_partition]
ORDER BY window_ordering
)
LISTAGG(
[DISTINCT] expression
[, delimiter]
)
[WITHIN GROUP
(ORDER BY order_list)]
OVER (
[PARTITION BY partition_expression] )		 STRING_AGG(
[DISTINCT] aggregate_expression
[, delimiter] )
OVER (
[PARTITION BY partition_list]
[ORDER BY order_list] )
MAX(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 MAX(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
MEDIAN(median_expression) OVER
(
[PARTITION BY partition_expression] ) 		PERCENTILE_CONT(
median_expression,
0.5
)
OVER ( [PARTITION BY partition_expression] )
MIN(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 MIN(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
NTH_VALUE(expression, offset) OVER ( [PARTITION BY window_partition] [ORDER BY window_ordering frame_clause] ) NTH_VALUE(expression, offset) OVER
(
[PARTITION BY window_partition]
ORDER BY window_ordering
[frame_clause]
)
NTILE(expr) OVER
(
[PARTITION BY expression_list]
[ORDER BY order_list]
) 		NTILE(expr) OVER
(
[PARTITION BY expression_list]
ORDER BY order_list
)
PERCENT_RANK() OVER
(
[PARTITION BY partition_expression]
[ORDER BY order_list]
) 		PERCENT_RANK() OVER
(
[PARTITION BY partition_expression]
ORDER BY order_list
)
PERCENTILE_CONT(percentile)
WITHIN GROUP (ORDER BY expr) OVER
(
[PARTITION BY expr_list] ) 		PERCENTILE_CONT(expr, percentile) OVER
(
[PARTITION BY expr_list] )
PERCENTILE_DISC(percentile) WITHIN GROUP (ORDER BY expr) OVER
(
[PARTITION BY expr_list]
) 		PERCENTILE_DISC(expr, percentile) OVER
(
[PARTITION BY expr_list] )
RANK() OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
)		 RANK() OVER
(
[PARTITION BY expr_list]
ORDER BY order_list
)
RATIO_TO_REPORT(ratio_expression) OVER
(
[PARTITION BY partition_expression] ) 		ratio_expression SUM(ratio_expression) OVER
(
[PARTITION BY partition_expression] )
ROW_NUMBER() OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
) 		ROW_NUMBER() OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
)
STDDEV(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 STDDEV(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause] )
STDDEV_SAMP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list
frame_clause]
)		 STDDEV_SAMP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
STDDEV_POP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
) 		STDDEV_POP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause] )
SUM(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
) 		SUM(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
VAR_POP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)		 VAR_POP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
VAR_SAMP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
) 		VAR_SAMP(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)
VARIANCE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)		 VARIANCE(expression) OVER
(
[PARTITION BY expr_list]
[ORDER BY order_list]
[frame_clause]
)

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
WHEN value THEN result
[WHEN...]
[ELSE else_result]
END		 CASE expression
WHEN value THEN result
[WHEN...]
[ELSE else_result]
END
COALESCE(expression1[, ...]) COALESCE(expression1[, ...])
DECODE(
expression,
search1, result1
[, search2, result2...]
[, default]
) 		CASE expression
WHEN value1 THEN result1
[WHEN value2 THEN result2]
[ELSE default]
END
GREATEST(value [, ...]) GREATEST(value [, ...])
LEAST(value [, ...]) LEAST(value [, ...])
NVL(expression1[, ...]) COALESCE(expression1[, ...])
NVL2(
expression,
not_null_return_value,
null_return_value
)		 IF(
expression IS NULL,
null_return_value,
not_null_return_value
)
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, datetime fecha y hora, 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(
date,
integer
)		 CAST( DATE_ADD(
date,
INTERVAL integer MONTH
)
AS TIMESTAMP
)
timestamptz_or_timestamp AT TIME ZONE timezone PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamptz_or_timestamp,
timezone
)
)

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(
[source_timezone],
target_timezone,
timestamp
)		 PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamp,
target_timezone
)
)

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
WHEN date1 = date2 THEN 0
WHEN date1 > date2 THEN 1
ELSE -1
END
DATE_CMP_TIMESTAMP(date1, date2) CASE
WHEN date1 = CAST(date2 AS DATE)
THEN 0
WHEN date1 > CAST(date2 AS DATE)
THEN 1
ELSE -1
END
DATE_CMP_TIMESTAMPTZ(date, timestamptz) CASE
WHEN date > DATE(timestamptz)
THEN 1
WHEN date < DATE(timestamptz)
THEN -1
ELSE 0
END
DATE_PART_YEAR(date) EXTRACT(YEAR FROM date)
DATEADD(date_part, interval, date) CAST(
DATE_ADD(
date,
INTERVAL interval datepart
)
AS TIMESTAMP
)
DATEDIFF(
date_part,
date_expression1,
date_expression2
) 		DATE_DIFF(
date_expression1,
date_expression2,
date_part
)
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(
"%c",
FORMAT_TIMESTAMP(
"%c",
CURRENT_TIMESTAMP()
)
)
INTERVAL_CMP(
interval_literal1,
interval_literal2
) 		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
parse_interval(interval_literal STRING) AS (
(select sum(case
when unit in ('minutes', 'minute', 'm' )
then num * 60
when unit in ('hours', 'hour', 'h') then num
* 60 * 60
when unit in ('days', 'day', 'd' ) then num
* 60 * 60 * 24
when unit in ('weeks', 'week', 'w') then num
* 60 * 60 * 24 * 7
when unit in ('months', 'month' ) then num *
60 * 60 * 24 * 30
when unit in ('years', 'year') then num * 60
* 60 * 24 * 360
else num
end)
from (
select
cast(regexp_extract(value,
r'^[0-9]*\.?[0-9]+') as numeric) num,
substr(value, length(regexp_extract(value,
r'^[0-9]*\.?[0-9]+')) + 1) unit
from
UNNEST(
SPLIT(
replace(
interval_literal, ' ', ''), ',')) value
)));

Para comparar los literales de intervalo, realiza lo siguiente:

IF(
parse_interval(interval_literal1) >
parse_interval(interval_literal2),
1,
IF(
parse_interval(interval_literal1) >
parse_interval(interval_literal2),
-1,
0
)
)
LAST_DAY(date) DATE_SUB(
DATE_ADD(
date,
INTERVAL 1 MONTH
),
INTERVAL 1 DAY
)
MONTHS_BETWEEN(
date1,
date2
) 		DATE_DIFF(
date1,
date2,
MONTH
)
NEXT_DAY(date, day) DATE_ADD(
DATE_TRUNC(
date,
WEEK(day)
),
INTERVAL 1 WEEK
)
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(
"%a %b %d %H:%M:%E6S %E4Y %Z",
CURRENT_TIMESTAMP())
TIMESTAMP_CMP(
timestamp1,
timestamp2
)		 CASE
WHEN timestamp1 = timestamp2
THEN 0
WHEN timestamp1 > timestamp2
THEN 1
ELSE -1
END
TIMESTAMP_CMP_DATE(
timestamp,
date
) 		CASE
WHEN
EXTRACT(
DATE FROM timestamp
) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamp) > date
THEN 1
ELSE -1
END
TIMESTAMP_CMP_TIMESTAMPTZ(
timestamp,
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
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Nota: BigQuery compara las marcas de tiempo en la zona horaria UTC.
TIMESTAMPTZ_CMP(
timestamptz1,
timestamptz2
)

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
WHEN timestamptz1 = timestamptz2
THEN 0
WHEN timestamptz1 > timestamptz2
THEN 1
ELSE -1
END

Nota: BigQuery compara las marcas de tiempo en la zona horaria UTC.
TIMESTAMPTZ_CMP_DATE(
timestamptz,
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
WHEN
EXTRACT(
DATE FROM timestamptz) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamptz) > date
THEN 1
ELSE -1
END

Nota: BigQuery compara las marcas de tiempo en la zona horaria UTC.
TIMESTAMPTZ_CMP_TIMESTAMP(
timestamptz,
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
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Nota: BigQuery compara las marcas de tiempo en la zona horaria UTC.
TIMEZONE(
timezone,
Timestamptz_or_timestamp
) 		PARSE_TIMESTAMP(
"%c%z", FORMAT_TIMESTAMP(
"%c%z",
timestamptz_or_timestamp,
timezone
)
)

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(
format,
FORMAT_TIMESTAMP(
format,
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:

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

X + Y

X + Y

X - Y

X - Y

X * Y

X * Y

X / Y


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:

CAST(X / Y AS INT64)


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

X % Y

MOD(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.

X ^ Y

POW(X, Y)

POWER(X, Y)


Nota: A diferencia de Amazon Redshift, el operador ^ en BigQuery realiza un proceso a nivel de bits.

| / X

SQRT(X)


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.

|| / X

SIGN(X) * POWER(ABS(X), 1/3)


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.

@ X

ABS(X)

X << Y

X << Y


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.

X >> Y

X >> Y


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.

X & Y

X & Y

X | Y

X | Y

~X

~X

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
WHEN string1 = string2 THEN 0
WHEN string1 > string2 THEN 1
ELSE -1
END
BTRIM(string [, matching_string]) TRIM(string [, matching_string])
BTTEXT_PATTERN_CMP(string1, string2) CASE
WHEN string1 = string2 THEN 0
WHEN string1 > string2 THEN 1
ELSE -1
END
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
[,position]
) 		ARRAY_LENGTH( REGEXP_EXTRACT_ALL(
source_string,
pattern
)
)

Si se especifica position:

ARRAY_LENGTH( REGEXP_EXTRACT_ALL(
SUBSTR(source_string, IF(position <= 0, 1, position)),
pattern
)
)

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(
source_string,
pattern
[,position
[,occurrence]] ) 		IFNULL( STRPOS(
source_string, REGEXP_EXTRACT(
source_string,
pattern)
),0)

Si se especifica source_string:

REGEXP_REPLACE(
source_string,

pattern,
replace_string
)

Si se especifica position:

IFNULL( STRPOS(
SUBSTR(source_string, IF(position
<= 0, 1, position)), REGEXP_EXTRACT(
SUBSTR(source_string, IF(position <= 0, 1, position)),
pattern)
) + IF(position <= 0, 1, position) - 1, 0)

Si se especifica occurrence:

IFNULL( STRPOS(
SUBSTR(source_string, IF(position
<= 0, 1, position)), REGEXP_EXTRACT_ALL(
SUBSTR(source_string, IF(position <= 0, 1, position)),
pattern
)[SAFE_ORDINAL(occurrence)]
) + IF(position <= 0, 1, position) - 1, 0)

Nota: BigQuery proporciona compatibilidad con expresiones regulares
mediante la biblioteca re2. Consulta esa documentación
para conocer su sintaxis de expresión
regular.
REGEXP_REPLACE( source_string,
pattern
[, replace_string [, position]]
) 		REGEXP_REPLACE(
source_string,
pattern,
""
)

Si se especifica source_string:

REGEXP_REPLACE(
source_string,

pattern, replace_string
)

Si se especifica position:

CASE
WHEN position > LENGTH(source_string) THEN source_string
WHEN position <= 0 THEN REGEXP_REPLACE(
source_string, pattern,
""
) ELSE
CONCAT( SUBSTR(
source_string, 1, position - 1), REGEXP_REPLACE(
SUBSTR(source_string, position), pattern,
replace_string
)
) END
REGEXP_SUBSTR( source_string, pattern
[, position
[, occurrence]] ) 		REGEXP_EXTRACT(
source_string, pattern
)

Si se especifica position:

REGEXP_EXTRACT(
SUBSTR(source_string, IF(position <= 0, 1, position)),
pattern

)

Si se especifica occurrence:

REGEXP_EXTRACT_ALL(
SUBSTR(source_string, IF(position <= 0, 1, position)),


pattern
)[SAFE_ORDINAL(occurrence)]

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(
string
delimiter
)SAFE_ORDINAL(part)
STRPOS(string, substring) STRPOS(string, substring)
STRTOL(string, base)
SUBSTRING(
string,
start_position, number_characters ) 		SUBSTR(
string,
start_position, number_characters )
TEXTLEN(expression) LENGTH(expression)
TRANSLATE(
expression,
characters_to_replace, characters_to_substitute ) 		Se puede implementar mediante UDF:

CREATE TEMP FUNCTION
translate(expression STRING,
characters_to_replace STRING, characters_to_substitute STRING) AS ( IF(LENGTH(characters_to_replace) < LENGTH(characters_to_substitute) OR LENGTH(expression) <
LENGTH(characters_to_replace), expression,
(SELECT
STRING_AGG(
IFNULL(
(SELECT ARRAY_CONCAT([c],
SPLIT(characters_to_substitute, ''))[SAFE_OFFSET((
SELECT IFNULL(MIN(o2) + 1,
0) FROM
UNNEST(SPLIT(characters_to_replace,
'')) AS k WITH OFFSET o2
WHERE k = c))]
),
''),
'' ORDER BY o1)
FROM UNNEST(SPLIT(expression, ''))
AS c WITH OFFSET o1
))
);
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(
timestamp_expression, format
)		 FORMAT_TIMESTAMP(
format,
timestamp_expression
)

Nota: BigQuery y Amazon Redshift difieren en cómo especificar una string de formato para timestamp_expression.
TO_CHAR(
numeric_expression,
format
)		 FORMAT(
format,
numeric_expression
)

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(
FORMAT(
format,
numeric_expression
) TO INT64
)

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 [, ...])
DEFAULT VALUES		 INSERT [INTO] table (column1 [, ...])
VALUES (DEFAULT [, ...])
INSERT INTO table (column1, [,...]) VALUES (
SELECT ...
FROM ...
)		 INSERT [INTO] table (column1, [,...])
SELECT ...
FROM ...

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
SET column = expression [,...] [FROM ...] 		UPDATE table
SET column = expression [,...]
[FROM ...]
WHERE TRUE

Nota: Todas las declaraciones UPDATE en BigQuery requieren una palabra clave WHERE, seguida de una condición.
UPDATE table
SET column = DEFAULT [,...] [FROM ...]
[WHERE ...]		 UPDATE table
SET column = NULL [, ...]
[FROM ...]
WHERE ...

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
WHERE TRUE

Las declaraciones DELETE de BigQuery requieren una cláusula WHERE.
DELETE FROM table_name
USING other_table
WHERE table_name.id=other_table.id		 DELETE FROM table_name
WHERE table_name.id IN (
SELECT id
FROM other_table
)

DELETE FROM table_name
WHERE EXISTS (
SELECT id
FROM other_table
WHERE table_name.id = other_table.id )

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 Para realizar una operación de combinación, reemplaza las filas existentes.

CREATE TEMP TABLE temp_table;

INSERT INTO temp_table
SELECT *
FROM source
WHERE source.filter = 'filter_exp';

BEGIN TRANSACTION;

DELETE FROM target
USING temp_table
WHERE target.key = temp_table.key;

INSERT INTO target
SELECT *
FROM temp_table;

END TRANSACTION;

DROP TABLE temp_table; 		MERGE target
USING source
ON target.key = source.key
WHEN MATCHED AND source.filter = 'filter_exp' THEN
UPDATE SET
target.col1 = source.col1,
target.col2 = source.col2,
...

Nota: Todas las columnas se deben enumerar si se actualizan todas.
Consulta Para realizar una operación de combinación, especifica una lista de columnas.

CREATE TEMP TABLE temp_table;

INSERT INTO temp_table
SELECT *
FROM source
WHERE source.filter = 'filter_exp';

BEGIN TRANSACTION;

UPDATE target SET
col1 = temp_table.col1,
col2 = temp_table.col2
FROM temp_table
WHERE target.key=temp_table.key;

INSERT INTO target
SELECT *
FROM 		MERGE target
USING source
ON target.key = source.key
WHEN MATCHED AND source.filter = 'filter_exp' THEN
UPDATE SET
target.col1 = source.col1,
target.col2 = source.col2

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
FROM ... 		INSERT table
SELECT expression, ...
FROM ...
WITH subquery_table AS ( SELECT ...
)
SELECT expression, ... INTO table
FROM subquery_table
... 		INSERT table
WITH subquery_table AS (
SELECT ...
)
SELECT expression, ...
FROM subquery_table
...
SELECT expression
INTO TEMP table
FROM ...

SELECT expression
INTO TEMPORARY table
FROM ... 		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 (
col1 data_type1 NOT NULL,
col2 data_type2 NULL,
col3 data_type3 UNIQUE,
col4 data_type4 PRIMARY KEY,
col5 data_type5
)

Nota: Las restricciones UNIQUE y PRIMARY KEY son informativas y no las aplica el sistema de Amazon Redshift.		 CREATE TABLE table_name (
col1 data_type1 NOT NULL,
col2 data_type2,
col3 data_type3,
col4 data_type4,
col5 data_type5,
)
CREATE TABLE table_name
(
col1 data_type1[,...]
table_constraints
)
where table_constraints are:
[UNIQUE(column_name [, ... ])]
[PRIMARY KEY(column_name [, ...])]
[FOREIGN KEY(column_name [, ...])
REFERENCES reftable [(refcolumn)]

Nota: Las restricciones UNIQUE y PRIMARY KEY son informativas y no las aplica el sistema de Amazon Redshift. 		CREATE TABLE table_name
(
col1 data_type1[,...]
)
PARTITION BY column_name
CLUSTER BY column_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
LIKE original_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
(
col1 data_type1
)
BACKUP NO

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
(
col1 data_type1
)
table_attributes
where table_attributes are:
[DISTSTYLE {AUTO|EVEN|KEY|ALL}]
[DISTKEY (column_name)]
[[COMPOUND|INTERLEAVED] SORTKEY
(column_name [, ...])] 		BigQuery es compatible con el agrupamiento en clústeres, lo que permite almacenar claves en orden.
CREATE TABLE table_name
AS SELECT ... 		CREATE TABLE table_name
AS SELECT ...
CREATE TABLE IF NOT EXISTS table_name ... CREATE TABLE IF NOT EXISTS
table_name
...

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
view_name AS
SELECT ...
CREATE VIEW view_name
(column_name, ...)
AS SELECT ... 		CREATE VIEW view_name AS SELECT ...
No compatible. CREATE VIEW IF NOT EXISTS c view_name
OPTIONS(view_option_list)
AS SELECT …

Crea una vista nueva solo si la vista no existe en el conjunto de datos especificado.
CREATE VIEW view_name
AS SELECT ...
WITH NO SCHEMA BINDING

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
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
sql_function_definition
$$ LANGUAGE sql 		CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) AS
sql_function_definition

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
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
{ VOLATILE | STABLE | IMMUTABLE } AS $$
sql_function_definition
$$ LANGUAGE sql 		CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
AS sql_function_definition

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
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
SELECT_clause
$$ LANGUAGE sql

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
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
AS sql_expression

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
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
sql_function_definition
$$ LANGUAGE sql 		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, los símbolos de dólares de Amazon Redshift ($$) is not supported in BigQuery.
CREATE [OR REPLACE] FUNCTION function_name (integer, integer) RETURNS integer IMMUTABLE AS $$ SELECT $1 + $2 $$ LANGUAGE sql CREATE [OR REPLACE] FUNCTION
function_name
(x INT64, y INT64)
RETURNS INT64
AS
SELECT x + y

Note: BigQuery UDFs require all input arguments to be named. The Amazon Redshift argument variables ($1, $2, …) are not supported in BigQuery.
CREATE [OR REPLACE] FUNCTION
function_name
(integer, integer)
RETURNS integer
IMMUTABLE
AS $$
SELECT $1 + $2
$$ LANGUAGE sql

Note: Amazon Redshift does not support ANY TYPE for SQL UDFs. However, it supports using the ANYELEMENT data type in Python-based UDFs. 		CREATE [OR REPLACE] FUNCTION
function_name
(x ANY TYPE, y ANY TYPE)
AS
SELECT x + y

Note: BigQuery supports using ANY TYPE as argument type. The function accepts an input of any type for this argument. For more information, see templated parameter in BigQuery.

BigQuery also supports the CREATE FUNCTION IF NOT EXISTS statement, which treats the query as successful and takes no action if a function with the same name already exists.

BigQuery's CREATE FUNCTION statement also supports creating TEMPORARY or TEMP functions, which do not have an Amazon Redshift equivalent.

See calling UDFs for details on executing a BigQuery-persistent UDF.

DROP FUNCTION syntax

The following table addresses differences in DROP FUNCTION syntax between Amazon Redshift and BigQuery.

Amazon Redshift BigQuery
DROP FUNCTION
function_name
( [arg_name] arg_type [, ...] ) [ CASCADE | RESTRICT ]		 DROP FUNCTION
dataset_name.function_name

Note: BigQuery does not require using the function's signature for deleting the function. Also, removing function dependencies is not supported in BigQuery.

BigQuery also supports the DROP FUNCTION IF EXISTS statement, which deletes the function only if the function exists in the specified dataset.

BigQuery requires that you specify the project_name if the function is not located in the current project.

UDF components

This section highlights the similarities and differences in UDF components between Amazon Redshift andBigQuery.

Component Amazon Redshift BigQuery
Name Amazon Redshift recommends using the prefix _f for function names to avoid conflicts with existing or future built-in SQL function names. In BigQuery, you can use any custom function name.
Arguments Arguments are optional. You can use name and data types for Python UDF arguments and only data types for SQL UDF arguments. In SQL UDFs, you must refer to arguments using $1, $2, and so on. Amazon Redshift also restricts the number of arguments to 32. Arguments are optional, but if you specify arguments, they must use both name and data types for both JavaScript and SQL UDFs. The maximum number of arguments for a persistent UDF is 256.
Data type Amazon Redshift supports a different set of data types for SQL and Python UDFs.
For a Python UDF, the data type might also be ANYELEMENT.

You must specify a RETURN data type for both SQL and Python UDFs.

See Data types in this document for equivalents between data types in Amazon Redshift and in BigQuery.		 BigQuery supports a different set of data types for SQL and JavaScript UDFs.
For a SQL UDF, the data type might also be ANY TYPE. For more information, see templated parameters in BigQuery.

The RETURN data type is optional for SQL UDFs.

See SQL type encodings in JavaScript for information on how BigQuery data types map to JavaScript data types.
Definition For both SQL and Python UDFs, you must enclose the function definition using dollar quoting, as in a pair of dollar signs ($$) para indicar el inicio y el final de las instrucciones de la función.

Para las 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 con la biblioteca estándar de Python 2.7 o importar tus módulos personalizados; para ello, crea uno con 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 con la sección OPTIONS . También puedes usar la herramienta de prueba de UDF de BigQuery para probar tus funciones.
Idioma 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
= 'T';		 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 ...
END TRANSACTION;		 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
table = 'T';		 SELECT * EXCEPT(is_typed) FROM
mydataset.INFORMATION_SCHEMA.TABLES;

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
statements EXCEPTION
BEGIN
statements
EXCEPTION
WHEN OTHERS THEN
Handler_statements
END;		 BEGIN
BEGIN
...
EXCEPTION WHEN ERROR THEN SELECT 1/0;
END;

EXCEPTION WHEN ERROR THEN -- The exception thrown from the inner exception handler lands here. END;

Declaraciones y operaciones del cursor

Debido a que BigQuery no admite cursores ni sesiones, las siguientes declaraciones no se usan en BigQuery:

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
THEN stmts
ELSE stmts
END IF
name CURSOR [ ( arguments ) ] FOR query Los cursores o las sesiones no se usan en BigQuery.
[< LOOP
sql_statement_list END LOOP;
WHILE condition LOOP stmts END LOOP WHILE condition
DO stmts
END WHILE
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 (tiene prioridad 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