Guía de traducción de SQL de Amazon Redshift

En este documento se detallan las similitudes y diferencias entre las sintaxis SQL 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 en bloque o la traducción de SQL interactiva para traducir consultas ad hoc.

Esta guía está dirigida a arquitectos empresariales, administradores de bases de datos, desarrolladores de aplicaciones y especialistas en seguridad de TI. Se presupone que conoces Amazon Redshift.

Tipos de datos

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

Amazon Redshift BigQuery Notas
Data type (Dato) Alias Data type (Dato)
SMALLINT INT2 INT64 SMALLINT de Amazon Redshift ocupa 2 bytes, mientras que INT64 de BigQuery ocupa 8 bytes.
INTEGER

INT, INT4

 INT64 El tipo INTEGER de Amazon Redshift ocupa 4 bytes, mientras que el tipo INT64 de BigQuery ocupa 8 bytes.
BIGINT INT8 INT64 Tanto BIGINT de Amazon Redshift como INT64 de BigQuery tienen 8 bytes.
DECIMAL NUMERIC NUMERIC
REAL FLOAT4 FLOAT64 El tipo REAL de Amazon Redshift ocupa 4 bytes, mientras que el tipo FLOAT64 de BigQuery ocupa 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 true. El tipo de datos BOOL de BigQuery usa un formato que no distingue entre mayúsculas y minúsculas.TRUE
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, las zonas horarias se usan al analizar marcas de tiempo o al darles formato para mostrarlas. Una marca de tiempo con formato de cadena puede incluir una zona horaria, pero cuando BigQuery analiza la cadena, almacena la marca de tiempo en la hora UTC equivalente. Si no se especifica una zona horaria, se usa la zona horaria predeterminada, UTC. Se admiten nombres de zonas horarias o desfases con respecto a UTC con el formato (-|+)HH:MM, pero no se admiten abreviaturas de zonas horarias, como PDT.
GEOMETRY GEOGRAPHY Compatibilidad con las consultas de datos geoespaciales.

BigQuery también tiene los siguientes tipos de datos que no tienen un análogo directo en Amazon Redshift:

Tipos de conversión implícita

Cuando migres a BigQuery, tendrás que convertir la mayoría de las conversiones implícitas de Amazon Redshift a conversiones explícitas de BigQuery, excepto en el caso de los siguientes tipos de datos, que BigQuery convierte implícitamente.

BigQuery realiza conversiones implícitas para los siguientes tipos de datos:

Tipo de BigQuery Tipo de BigQuery

INT64

FLOAT64

INT64

NUMERIC

NUMERIC

FLOAT64

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

Tipo de BigQuery Tipo de BigQuery
STRING literal
(por ejemplo, "2008-12-25")

DATE

STRING literal
(por ejemplo, "2008-12-25 15:30:00")

TIMESTAMP

STRING literal
(por ejemplo, "2008-12-25T07:30:00")

DATETIME

STRING literal
(por ejemplo, "15:30:00")

TIME

Tipos de conversión explícita

Puedes convertir los tipos de datos de Amazon Redshift que BigQuery no convierte implícitamente mediante la función CAST(expression AS type) de BigQuery o cualquiera de las funciones de conversión DATE y TIMESTAMP.

Cuando migres tus consultas, cambia todas las instancias de la función CONVERT(type, expression) de Amazon Redshift (o la sintaxis ::) por la función CAST(expression AS type) de BigQuery, tal como se muestra en la tabla de la sección Funciones de formato de tipo de datos.

Sintaxis de consulta

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

SELECT declaración

La mayoría de las instrucciones de Amazon Redshift SELECT son compatibles con BigQuery. En la siguiente tabla se muestra 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 permite crear y hacer referencia a un alias en la misma SELECT instrucción.

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

BigQuery también admite las siguientes expresiones en las instrucciones SELECT, que no tienen un equivalente en Amazon Redshift:

Cláusula FROM

Una cláusula FROM de una consulta muestra las referencias de la tabla de la que se seleccionan los datos. En Amazon Redshift, las referencias de tabla 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 con lo siguiente:

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

BigQuery también admite referencias de tabla adicionales:

Tipos de JOIN

Tanto Amazon Redshift como BigQuery admiten los siguientes tipos de combinaciones:

En la siguiente tabla se muestra 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 que una de las tablas combinadas sea un campo de un tipo de datos o una matriz.

Cláusula WITH

Una cláusula BigQuery WITH contiene una o varias subconsultas con nombre que se ejecutan cuando una instrucción SELECT posterior hace referencia a ellas. Las cláusulas de Amazon Redshift WITH se comportan igual que las de BigQuery, con la excepción de que puedes evaluar la cláusula una vez y reutilizar sus resultados.

Operadores de conjuntos

Hay 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 se pueden realizar 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: Tanto BigQuery como 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 las distintas operaciones de conjuntos. Si se repite el mismo operador de conjunto, no es necesario usar paréntesis.

Cláusula ORDER BY

Hay algunas diferencias menores entre las cláusulas de Amazon Redshift ORDER BY y las de BigQuery ORDER BY.

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 (en 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 da como resultado el mismo comportamiento que la cláusula LIMIT ALL de Amazon Redshift. Te recomendamos que incluyas una cláusula LIMIT con cada cláusula ORDER BY. Ordenar todas las filas de resultados innecesariamente reduce el rendimiento de la ejecución de las consultas.

SELECT *
FROM table
ORDER BY expression
OFFSET 10

SELECT *
FROM table
ORDER BY expression
LIMIT count OFFSET 10



Nota: En BigQuery, OFFSET debe usarse junto con un LIMIT recuento. Asegúrate de definir el valor de count INT64 en el número mínimo de filas ordenadas necesarias. Ordenar todas las filas de resultados
reduce innecesariamente el rendimiento de la ejecución de la consulta.

Condiciones

En la siguiente tabla se muestran las condiciones de Amazon Redshift, o predicados, que son específicas de Amazon Redshift y deben convertirse a 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, envuelve la expresión anterior IF en una expresión NOT como se muestra a continuación:

NOT(
IF(
LENGTH(...
)

expression [!] ~ pattern

[NOT] REGEXP_CONTAINS(
expression,
regex
)

Functions

En las siguientes secciones se enumeran las funciones de Amazon Redshift y sus equivalentes en BigQuery.

Funciones de agregación

En la siguiente tabla se muestran las asignaciones entre las funciones de agregación, agregación analítica y agregación aproximada de Amazon Redshift más habituales y sus equivalentes en 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 se incluyen 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, de analíticas de agregación y de agregación aproximada, que no tienen una función análoga directa en Amazon Redshift:

Funciones de agregación bit a bit

En la siguiente tabla se muestran las asignaciones entre las funciones de agregación bit a bit de Amazon Redshift más habituales y sus equivalentes en BigQuery.

Amazon Redshift BigQuery
BIT_AND(expression) BIT_AND(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 bit a bit, que no tiene un análogo directo en Amazon Redshift:

Funciones de ventana

En la siguiente tabla se muestran las asignaciones entre las funciones de ventana comunes de Amazon Redshift y sus equivalentes en BigQuery. Las funciones de ventana de BigQuery incluyen: funciones de agregación analíticas, funciones de agregación, 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 y sus equivalentes en 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 de fecha y hora de Amazon Redshift más habituales y sus equivalentes en BigQuery. Las funciones de fecha y hora de BigQuery incluyen funciones de fecha, funciones de fecha y hora, funciones de hora y funciones de marca de tiempo.

Ten en cuenta que las funciones que parecen idénticas en Amazon Redshift y BigQuery pueden devolver tipos de datos diferentes.

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 al analizar marcas de tiempo o al darles formato para mostrarlas. Una marca de tiempo con formato de cadena puede incluir una zona horaria, pero cuando BigQuery analiza la cadena, almacena la marca de tiempo en la hora UTC equivalente. Si no se especifica una zona horaria, se usa la zona horaria predeterminada, UTC. Se admiten nombres de zonas horarias o desfases con respecto al tiempo UTC (-HH:MM), pero no abreviaturas de zonas horarias (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: Devuelve la fecha de inicio de la transacción actual en la zona horaria de la sesión actual (UTC de forma predeterminada). 		CURRENT_DATE()

Nota: Devuelve la fecha de inicio del extracto 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 Redshift, los intervalos tienen 360 días al año. En BigQuery, puede 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 literales de intervalo, haz 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: Devuelve 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: Devuelve la marca de tiempo de inicio de la instrucció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 del usuario. La zona horaria predeterminada de las sesiones de 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 del usuario. La zona horaria predeterminada de las sesiones de 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 del usuario. La zona horaria predeterminada de las sesiones de 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 del usuario. La zona horaria predeterminada de las sesiones de 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 al analizar marcas de tiempo o al darles formato para mostrarlas. Una marca de tiempo con formato de cadena puede incluir una zona horaria, pero cuando BigQuery analiza la cadena, almacena la marca de tiempo en la hora UTC equivalente. Si no se especifica una zona horaria, se usa la zona horaria predeterminada, UTC. Se admiten nombres de zonas horarias o desfases con respecto a UTC (-HH:MM), pero no abreviaturas de zonas horarias (como PDT).
TO_TIMESTAMP(timestamp, format) PARSE_TIMESTAMP(
format,
FORMAT_TIMESTAMP(
format,
timestamp
)
)

Nota: BigQuery sigue otro conjunto de elementos de formato. Las zonas horarias se usan al analizar marcas de tiempo o al darles formato para mostrarlas. Una marca de tiempo con formato de cadena puede incluir una zona horaria, pero cuando BigQuery analiza la cadena, almacena la marca de tiempo en la hora UTC equivalente. Si no se especifica una zona horaria, se usa la zona horaria predeterminada, UTC. En la cadena de formato se admiten nombres de zonas horarias o desfases con respecto al tiempo UTC (-HH:MM), pero no 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 los operadores matemáticos comunes de Amazon Redshift y sus equivalentes en BigQuery.

Amazon Redshift BigQuery

X + Y

X + Y

X - Y

X - Y

X * Y

X * Y

X / Y


Nota: Si el operador realiza una división entera (es decir, si X y Y son números enteros), se devuelve un número entero.
Si el operador realiza una división no entera, se devuelve un valor no entero.		 Si es una división entera:
CAST(FLOOR(X / Y) AS INT64)

Si no es una división entera:

CAST(X / Y AS INT64)


Nota: La división en BigQuery devuelve un valor no entero.
Para evitar errores en una operación de división (error de división entre cero), usa SAFE_DIVIDE(X, Y) o IEEE_DIVIDE(X, Y).

X % Y

MOD(X, Y)


Nota: Para evitar errores en una operación de división (error de división entre cero), usa SAFE.MOD(X, Y). SAFE.MOD(X, 0) resultados en 0.

X ^ Y

POW(X, Y)

POWER(X, Y)


Nota: A diferencia de Amazon Redshift, el operador ^ de BigQuery realiza una operación XOR bit a bit.

| / X

SQRT(X)


Nota: Para evitar errores en una operación de raíz cuadrada (entrada negativa), usa SAFE.SQRT(X). Si se introduce un valor negativo con SAFE.SQRT(X), se obtiene NULL.

|| / X

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


Nota: La función POWER(X, Y) de BigQuery devuelve un error si X es un valor finito menor que 0 y Y no es un número entero.

@ X

ABS(X)

X << Y

X << Y


Nota: Este operador devuelve 0 o una secuencia de bytes b'\x00' si el segundo operando Y es mayor o igual que la longitud en bits del primer operando X (por ejemplo, 64 si X tiene el tipo INT64). Este operador genera un error si Y es negativo.

X >> Y

X >> Y


Nota: Desplaza el primer operando X hacia la derecha. Este operador no hace una extensión de bits de signo con un tipo con signo (rellena los bits vacíos de la izquierda con 0). Este operador devuelve 0 o una secuencia de bytes de
b'\x00' si el segundo operando Y es mayor o igual que la longitud de bits del primer operando X (por ejemplo, 64 si X tiene el tipo INT64). Este operador devuelve 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 cadena

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: La función CONCAT(...) de BigQuery admite
la concatenación de cualquier número de cadenas.
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 ofrece compatibilidad con expresiones regulares mediante la biblioteca re2. Consulte la documentación para ver la sintaxis de las expresiones regulares.
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 ofrece compatibilidad con expresiones regulares
mediante la biblioteca re2 . Consulte la documentación
para ver la sintaxis de las expresiones regulares
.
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 ofrece compatibilidad con expresiones regulares mediante la biblioteca re2. Consulte la documentación de esa biblioteca para ver la sintaxis de las expresiones regulares.
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 funciones definidas por el usuario:

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 tipos 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 la forma de especificar una cadena de formato para timestamp_expression.
TO_CHAR(
numeric_expression,
format
)		 FORMAT(
format,
numeric_expression
)

Nota: BigQuery y Amazon Redshift difieren en la forma de especificar una cadena de formato para timestamp_expression.
TO_DATE(date_string, format) PARSE_DATE(date_string, format)

Nota: BigQuery y Amazon Redshift difieren en la forma de especificar una cadena de formato para date_string.
TO_NUMBER(string, format) CAST(
FORMAT(
format,
numeric_expression
) TO INT64
)

Nota: BigQuery y Amazon Redshift difieren en la forma de especificar una cadena de formato numérico.

BigQuery también admite SAFE_CAST(expression AS typename), que devuelve NULL si BigQuery no puede realizar una conversión. Por ejemplo, SAFE_CAST("apple" AS INT64) devuelve NULL.

Sintaxis de DML

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

INSERT declaración

Amazon Redshift ofrece una palabra clave DEFAULT configurable para las columnas. En BigQuery, el valor DEFAULT de las columnas que admiten valores nulos es NULL, y DEFAULT no se admite en las columnas obligatorias. La mayoría de las instrucciones de Amazon RedshiftINSERT 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 (donde uno de los valores se calcula mediante una subconsulta), lo que no se admite en Amazon Redshift. Por ejemplo:

INSERT INTO table (column1, column2)
VALUES ('value_1', (
SELECT column2
FROM table2
))

COPY declaración

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 varias herramientas y opciones que no son de SQL para cargar datos en tablas de BigQuery. También puedes usar los receptores de la canalización de datos que se proporcionan en Apache Spark o Apache Beam para escribir datos en BigQuery.

UPDATE declaración

La mayoría de las instrucciones de 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 instrucciones UPDATE de BigQuery requieren la 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 instrucción UPDATE de Amazon Redshift no incluye una cláusula WHERE, la instrucción UPDATE de BigQuery debe estar condicionada WHERE TRUE.

DELETE y TRUNCATE

Las instrucciones DELETE y TRUNCATE son dos formas de eliminar filas de una tabla sin afectar al esquema ni a los índices de la tabla.

En Amazon Redshift, se recomienda usar la instrucción TRUNCATE en lugar de una instrucción DELETE sin calificar, ya que es más rápida y no requiere operaciones VACUUM y ANALYZE después. Sin embargo, puede usar las instrucciones DELETE para conseguir el mismo efecto.

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

Amazon Redshift BigQuery
DELETE [FROM] table_name

TRUNCATE [TABLE] table_name		 DELETE FROM table_name
WHERE TRUE

Las instrucciones de 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 hacer referencia a tablas adicionales en la cláusula WHERE. Esto se puede hacer en BigQuery usando una subconsulta en la cláusula WHERE.

MERGE declaración

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

Amazon Redshift no admite un solo comando MERGE. Sin embargo, se puede realizar una operación de combinación en Amazon Redshift realizando operaciones INSERT, UPDATE y DELETE en una transacción.

Operación de combinación que sustituye las filas

En Amazon Redshift, se pueden sobrescribir todas las columnas de la tabla de destino mediante una instrucción DELETE y, a continuación, una instrucción INSERT. La instrucción DELETE elimina las filas que se deben actualizar y, a continuación, la instrucción INSERT inserta las filas actualizadas. Las tablas de BigQuery están limitadas a 1000 instrucciones DML al día, por lo que debes consolidar las instrucciones INSERT, UPDATE y DELETE en una sola instrucción MERGE, tal como se muestra en la siguiente tabla.

Amazon Redshift BigQuery
Consulta cómo realizar una operación de combinación sustituyendo filas ya 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: Deben incluirse todas las columnas si se van a actualizar todas.
Consulte Combinar datos especificando 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 de DDL

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

SELECT INTO declaración

En Amazon Redshift, la instrucción SELECT INTO se puede usar para insertar los resultados de una consulta en una tabla nueva, combinando la creación de la tabla y la inserción.

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. Para obtener más información, consulta la sección sobre tablas temporales.

CREATE TABLE declaración

La mayoría de las instrucciones de Amazon Redshift CREATE TABLE son compatibles con BigQuery, excepto los siguientes elementos de 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 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 ni FOREIGN KEY. Para conseguir una optimización similar a la que proporcionan estas restricciones durante la ejecución de las consultas, crea particiones y clústeres en tus tablas de BigQuery. CLUSTER BY admite hasta 4 columnas.
CREATE TABLE table_name
LIKE original_table_name 		Consulta este ejemplo para saber cómo usar las tablas INFORMATION_SCHEMA para 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, se especifica el ajuste BACKUP NO para ahorrar tiempo de procesamiento y reducir el espacio de almacenamiento.		 La opción de tabla BACKUP NO no se usa ni es necesaria porque BigQuery mantiene automáticamente hasta 7 días de versiones históricas de todas tus tablas sin que esto afecte al tiempo de procesamiento ni al 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 admite el agrupamiento en clústeres, que permite almacenar claves en orden ordenado.
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 instrucción DDL CREATE OR REPLACE TABLE, que sobrescribe una tabla si ya existe.

La instrucción CREATE TABLE de BigQuery también admite las siguientes cláusulas, que no tienen un equivalente en Amazon Redshift:

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

Tablas temporales

Amazon Redshift admite tablas temporales, que solo se pueden ver en la sesión actual. Hay varias formas de emular tablas temporales en BigQuery:

  • TTL del conjunto de datos: crea un conjunto de datos con un tiempo de vida breve (por ejemplo, una hora) para que las tablas creadas en el conjunto de datos sean temporales, ya que no se conservarán más tiempo que el tiempo de vida del conjunto de datos. Puedes añadir el prefijo temp a todos los nombres de las tablas de este conjunto de datos para indicar claramente que son temporales.

  • TTL de tabla: crea una tabla que tenga un tiempo de vida breve específico de la tabla mediante declaraciones de DDL similares a las siguientes:

    CREATE TABLE
temp.name (col1, col2, ...)
OPTIONS (expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),
INTERVAL 1 HOUR));

CREATE VIEW declaración

En la siguiente tabla se muestran las equivalencias entre Amazon Redshift y BigQuery para la instrucción CREATE VIEW.

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

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

En Amazon Redshift, se necesita una vista de enlace tardío para hacer referencia a una tabla externa.		 En BigQuery, para crear una vista, todos los objetos referenciados deben existir.

BigQuery te permite consultar fuentes de datos externas.

Funciones definidas por el usuario (UDF)

Una función definida por el usuario te permite crear funciones para operaciones personalizadas. Estas funciones aceptan columnas de entrada, realizan acciones y devuelven el resultado de esas acciones como un valor.

Tanto Amazon Redshift como BigQuery admiten funciones definidas por el usuario mediante expresiones SQL. Además, en Amazon Redshift puedes crear una UDF basada en Python, y en BigQuery puedes crear una UDF basada en JavaScript.

Consulta el repositorio de GitHub de utilidades de Google Cloud BigQuery para ver una biblioteca de UDFs de BigQuery comunes.

Sintaxis de CREATE FUNCTION

En la siguiente tabla se muestran las diferencias en la sintaxis de creación de funciones definidas por el usuario 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 devuelto es opcional. BigQuery deduce 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 las funciones no es un parámetro configurable en BigQuery. Toda la volatilidad de las funciones definidas por el usuario de BigQuery es equivalente a la volatilidad de IMMUTABLEde Amazon Redshift (es decir, no realiza búsquedas en la base de datos ni usa información que no esté presente directamente 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 de las cláusulas FROM, INTO, WHERE, GROUP BY, ORDER BY, ni 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 SQL como definición de función. Sin embargo, no se admite hacer 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 el literal de idioma en una función definida por el usuario de GoogleSQL. BigQuery interpreta la expresión SQL de forma predeterminada. También se usa la comilla de dólar 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 Supported JavaScript UDF data types 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.

En el caso de las UDFs de SQL,Amazon Redshift solo admite una SELECT cláusula SQL como definición de función. Además, la cláusula SELECT no puede incluir ninguna de las cláusulas FROM, INTO, WHERE, GROUP
, BY, ORDER BY y LIMIT .

En el caso de las UDFs de Python, puedes escribir un programa de Python con la biblioteca estándar de Python 2.7 o importar tus módulos personalizados creando uno con el comando CREATE LIBRARY .		 En BigQuery, debes incluir el código JavaScript entre comillas. Consulta las reglas de presupuestos para obtener más información.

En el caso de las FDUs de SQL, puedes usar cualquier expresión SQL como definición de la función. Sin embargo, BigQuery no admite referencias a tablas, vistas ni modelos.

En el caso de las funciones definidas por el usuario de JavaScript, puedes incluir bibliotecas de código externo directamente mediante la sección OPTIONS . También puedes usar la herramienta de prueba de UDFs de BigQuery para probar tus funciones.
Idioma Debes usar el literal LANGUAGE para especificar el idioma como sql en el caso de las funciones definidas por el usuario de SQL o plpythonu en el caso de las funciones definidas por el usuario de Python. No es necesario especificar LANGUAGE en las FDU de SQL, pero sí debes especificar el lenguaje como js en las FDU de JavaScript.
Estado Amazon Redshift no admite la creación de UDFs temporales.

Amazon Redshift ofrece la opción de definir la volatilidad de una función mediante literales VOLATILE, STABLE o IMMUTABLE . El optimizador de consultas la usa para la optimización.		 BigQuery admite funciones definidas por el usuario persistentes y temporales. Las FDUs persistentes se pueden reutilizar en varias consultas, mientras que las FDUs temporales solo se pueden usar en una consulta.

La volatilidad de las funciones no es un parámetro configurable en BigQuery. Toda la volatilidad de las UDF de BigQuery es equivalente a la IMMUTABLE volatilidad de Amazon Redshift.
Seguridad y privilegios Para crear una UDF, debes tener permiso para usar el lenguaje de SQL o plpythonu (Python). De forma predeterminada, se concede USAGE ON LANGUAGE SQL a PUBLIC, pero debes conceder USAGE ON LANGUAGE PLPYTHONU explícitamente a usuarios o grupos específicos.
Además, debes ser superusuario para sustituir una función definida por el usuario.		 En BigQuery, no es necesario conceder permisos explícitos para crear o eliminar ningún tipo de UDF. Cualquier usuario al que se le haya asignado el rol Editor de datos de BigQuery (que tenga bigquery.routines.* como uno de los permisos) puede crear o eliminar funciones del conjunto de datos especificado.

BigQuery también permite crear roles personalizados. Esto se puede gestionar con Cloud IAM.
Límites Consulta los límites de las UDFs de Python. Consulta los límites de las funciones definidas por el usuario.

Declaraciones SQL de metadatos y transacciones

Amazon Redshift BigQuery
SELECT * FROM STL_ANALYZE WHERE name
= 'T';		 No se usa en BigQuery. No es necesario recoger estadísticas para mejorar el rendimiento de las consultas. Para obtener información sobre la distribución de tus datos, puedes usar funciones de agregación aproximada.
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 consulta en la consola de BigQuery Google Cloud y 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 la introducción a BigQuery INFORMATION_SCHEMA.
VACUUM [table_name] No se usa en BigQuery. Las tablas agrupadas de BigQuery se ordenan automáticamente.

Instrucciones SQL de varias líneas y con varias instrucciones

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

Declaraciones SQL procedimentales

CREATE PROCEDURE declaración

Amazon Redshift BigQuery
CREATE or REPLACE PROCEDURE CREATE PROCEDURE si es necesario indicar un nombre.

De lo contrario, úsalo en línea 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

Asigna a una variable el valor de la expresión proporcionada o asigna varias variables al mismo tiempo en función del resultado de varias expresiones.

Controladores de condiciones de error

En Amazon Redshift, si se produce un error durante la ejecución de un procedimiento almacenado, se detiene el flujo de ejecución, se finaliza la transacción y se revierte la transacción. Estos resultados se producen porque no se admiten las subtransacciones. En un procedimiento almacenado de 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 ofrecen 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 de cursores

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

Si usas el cursor para devolver un conjunto de resultados, puedes conseguir un comportamiento similar con las tablas temporales de BigQuery.

Instrucciones SQL dinámicas

La función de scripting de BigQuery admite instrucciones 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 En BigQuery no se usan cursores ni sesiones.
[< 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 transacciones

Tanto Amazon Redshift como BigQuery son atómicos, es decir, cumplen los requisitos de ACID a nivel de mutación en muchas filas.

Transacciones

Amazon Redshift admite el aislamiento serializable de forma predeterminada en las transacciones. Amazon Redshift te permite especificar cualquiera de los cuatro niveles de aislamiento de transacciones 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 concurrencia optimista (el primero en confirmar tiene prioridad) con el aislamiento de instantáneas, en el que una consulta lee los últimos datos confirmados antes de que empiece la consulta. Este enfoque garantiza el mismo nivel de coherencia por fila y por mutación, así como entre las filas de la misma instrucción DML, pero evita los interbloqueos. En el caso de que se realicen varias actualizaciones de DML en la misma tabla, BigQuery cambia al control de concurrencia pesimista. Las tareas de carga se pueden ejecutar de forma completamente independiente y añadir datos a las tablas.

Restauración

Si Amazon Redshift detecta algún error al ejecutar un procedimiento almacenado, revierte todos los cambios realizados en una transacción. Además, puedes usar la instrucción de control de transacciones ROLLBACK en un procedimiento almacenado para descartar todos los cambios.

En BigQuery, puedes usar la instrucción ROLLBACK TRANSACTION.

Límites de las bases de datos

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

Límite Amazon Redshift BigQuery
Tablas de cada base de datos para los tipos de nodos de clúster grandes y extragrandes 9900 Sin restricción
Tablas de cada base de datos para los tipos de nodos de clúster 8xlarge 20.000 Sin restricción
Bases de datos definidas por el usuario que puedes crear para cada clúster 60 Sin restricción
Tamaño máximo de las filas 4 MB 100 MB