Guia de tradução de SQL do Amazon Redshift

Este documento detalha as semelhanças e as diferenças na sintaxe SQL entre o Amazon Redshift e o BigQuery para ajudar a planear a sua migração. Use a tradução de SQL em lote para migrar os seus scripts SQL em massa ou a tradução de SQL interativa para traduzir consultas ad hoc.

O público-alvo deste guia são arquitetos empresariais, administradores de bases de dados, programadores de aplicações e especialistas em segurança de TI. Parte do princípio de que conhece o Amazon Redshift.

Tipos de dados

Esta secção mostra os equivalentes entre os tipos de dados no Amazon Redshift e no BigQuery.

Amazon Redshift BigQuery Notes
Tipo de dados Alias Tipo de dados
SMALLINT INT2 INT64 O SMALLINT do Amazon Redshift tem 2 bytes, enquanto o INT64 do BigQuery tem 8 bytes.
INTEGER

INT, INT4

 INT64 O INTEGER do Amazon Redshift tem 4 bytes, enquanto o INT64 do BigQuery tem 8 bytes.
BIGINT INT8 INT64 Tanto o BIGINT do Amazon Redshift como o INT64 do BigQuery têm 8 bytes.
DECIMAL NUMERIC NUMERIC
REAL FLOAT4 FLOAT64 O REAL do Amazon Redshift tem 4 bytes, enquanto o FLOAT64 do BigQuery tem 8 bytes.
DOUBLE PRECISION

FLOAT8, FLOAT

 FLOAT64
BOOLEAN BOOL BOOL O BOOLEAN do Amazon Redshift pode usar TRUE, t, true, y, yes e 1 como valores literais válidos para verdadeiro. O tipo de dados do BigQuery usa a opção não sensível a maiúsculas e minúsculas.BOOLTRUE
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: no BigQuery, os fusos horários são usados ao analisar as datas/horas ou ao formatar as datas/horas para apresentação. Uma data/hora formatada como string pode incluir um fuso horário, mas quando o BigQuery analisa a string, armazena a data/hora na hora UTC equivalente. Quando não é especificado explicitamente um fuso horário, é usado o fuso horário predefinido, UTC. Os nomes dos fusos horários ou a diferença horária entre UTC através de (-|+)HH:MM são suportados, mas as abreviaturas dos fusos horários, como PDT, não são suportadas.
GEOMETRY GEOGRAPHY Suporte para consultar dados geoespaciais.

O BigQuery também tem os seguintes tipos de dados que não têm um análogo direto no Amazon Redshift:

Tipos de conversões implícitas

Quando migra para o BigQuery, tem de converter a maioria das conversões implícitas do Amazon Redshift em conversões explícitas do BigQuery, exceto para os seguintes tipos de dados, que o BigQuery converte implicitamente.

O BigQuery faz conversões implícitas para os seguintes tipos de dados:

Do tipo BigQuery Para o tipo do BigQuery

INT64

FLOAT64

INT64

NUMERIC

NUMERIC

FLOAT64

O BigQuery também faz conversões implícitas para os seguintes literais:

Do tipo BigQuery Para o tipo do BigQuery
STRING literal
(por exemplo, "2008-12-25")

DATE

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

TIMESTAMP

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

DATETIME

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

TIME

Tipos de conversão explícitos

Pode converter tipos de dados do Amazon Redshift que o BigQuery não converte implicitamente usando a função CAST(expression AS type) do BigQuery ou qualquer uma das funções de conversão DATE e TIMESTAMP.

Quando migrar as suas consultas, altere todas as ocorrências da função Amazon Redshift CONVERT(type, expression) (ou a sintaxe ::) para a função CAST(expression AS type) do BigQuery, conforme mostrado na tabela na secção Funções de formatação de tipos de dados.

Sintaxe de consulta

Esta secção aborda as diferenças na sintaxe de consulta entre o Amazon Redshift e o BigQuery.

SELECT declaração

A maioria das declarações do Amazon Redshift SELECT é compatível com o BigQuery. A tabela seguinte contém uma lista de diferenças 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: o Redshift suporta a criação e a referência de um alias na mesma SELECT declaração.

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

O BigQuery também suporta as seguintes expressões em declarações SELECT, que não têm um equivalente no Amazon Redshift:

FROM cláusula

Uma cláusula FROM numa consulta apresenta as referências de tabelas a partir das quais os dados são selecionados. No Amazon Redshift, as referências de tabelas possíveis incluem tabelas, vistas e subconsultas. Todas estas referências de tabelas são suportadas no BigQuery.

As tabelas do BigQuery podem ser referenciadas na cláusula FROM através do seguinte:

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

O BigQuery também suporta referências de tabelas adicionais:

JOIN tipos

O Amazon Redshift e o BigQuery suportam os seguintes tipos de junção:

A tabela seguinte contém uma lista de pequenas diferenças.

Amazon Redshift BigQuery

SELECT col
FROM table1
NATURAL INNER JOIN
table2

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


Nota: no BigQuery, as cláusulas JOIN requerem uma condição JOIN, a menos que a cláusula seja CROSS JOIN ou uma das tabelas associadas seja um campo num tipo de dados ou numa matriz.

WITH cláusula

Uma cláusula WITH do BigQuery contém uma ou mais subconsultas com nome que são executadas quando uma declaração SELECT subsequente faz referência às mesmas. Amazon Redshift WITH As cláusulas comportam-se da mesma forma que as do BigQuery, com a exceção de que pode avaliar a cláusula uma vez e reutilizar os respetivos resultados.

Operadores de conjuntos

Existem algumas pequenas diferenças entre os operadores de conjuntos do Amazon Redshift e os operadores de conjuntos do BigQuery . No entanto, todas as operações de conjunto que são viáveis no Amazon Redshift são replicáveis no BigQuery.

Amazon Redshift BigQuery

SELECT * FROM table1
UNION
SELECT * FROM table2

SELECT * FROM table1
UNION DISTINCT
SELECT * FROM table2

Nota: o BigQuery e o Amazon Redshift suportam o 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: o BigQuery requer parênteses para separar diferentes operações de conjuntos. Se o mesmo operador de conjunto for repetido, os parênteses não são necessários.

ORDER BY cláusula

Existem algumas diferenças menores entre as cláusulas ORDER BY do Amazon Redshift e as cláusulas ORDER BY do BigQuery.

Amazon Redshift BigQuery
No Amazon Redshift, os NULL são classificados por último por predefinição (ordem ascendente). No BigQuery, os NULLs são classificados primeiro por predefinição (por ordem ascendente).

SELECT *
FROM table
ORDER BY expression
LIMIT ALL

SELECT *
FROM table
ORDER BY expression



Nota: o BigQuery não usa a sintaxe LIMIT ALL, mas ORDER BY ordena todas as linhas por predefinição, o que resulta no mesmo comportamento que a cláusula LIMIT ALL do Amazon Redshift. Recomendamos vivamente que inclua uma cláusula LIMIT com cada cláusula ORDER BY. Ordenar todas as linhas de resultados desnecessariamente degrada o desempenho da execução de consultas.

SELECT *
FROM table
ORDER BY expression
OFFSET 10

SELECT *
FROM table
ORDER BY expression
LIMIT count OFFSET 10



Nota: no BigQuery, OFFSET tem de ser usado em conjunto com uma LIMIT contagem. Certifique-se de que define o valor de count INT64 para o mínimo de linhas necessárias ordenadas. Ordenar todas as linhas de resultados
degrada desnecessariamente o desempenho da execução de consultas.

Condições

A tabela seguinte mostra as condições do Amazon Redshift, ou predicados, que são específicos do Amazon Redshift e têm de ser convertidos no respetivo equivalente do 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: o BigQuery não suporta carateres de escape personalizados. Tem de usar duas barras invertidas \\ como carateres de escape para o BigQuery.

expression [NOT] SIMILAR TO pattern

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


Nota: se NOT for especificado, envolva a expressão IF acima numa expressão NOT, conforme mostrado abaixo:

NOT(
IF(
LENGTH(...
)

expression [!] ~ pattern

[NOT] REGEXP_CONTAINS(
expression,
regex
)

Funções

As secções seguintes listam as funções do Amazon Redshift e os respetivos equivalentes no BigQuery.

Funções de agregação

A tabela seguinte mostra os mapeamentos entre funções de agregação, funções analíticas de agregação e funções de agregação aproximadas comuns do Amazon Redshift com os respetivos equivalentes no 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: não abrange exemplos de utilização de agregação.
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)

O BigQuery também oferece as seguintes funções de agregação, agregação analítica e agregação aproximada, que não têm um análogo direto no Amazon Redshift:

Funções de agregação bit a bit

A tabela seguinte mostra mapeamentos entre funções agregadas bit a bit comuns do Amazon Redshift com os respetivos equivalentes no 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)

O BigQuery também oferece a seguinte função de agregação bit a bit, que não tem um análogo direto no Amazon Redshift:

Funções de janela

A tabela seguinte mostra os mapeamentos entre as funções de janela comuns do Amazon Redshift e os respetivos equivalentes no BigQuery. As funções de janelas no BigQuery incluem funções de agregação analíticas, funções de agregação, funções de navegação> e funções de numeração.


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

Expressões condicionais

A tabela seguinte mostra mapeamentos entre expressões condicionais comuns do Amazon Redshift com os respetivos equivalentes do 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)

O BigQuery também oferece as seguintes expressões condicionais, que não têm um análogo direto no Amazon Redshift:

Funções de data e hora

A tabela seguinte mostra mapeamentos entre funções comuns de data e hora do Amazon Redshift com os respetivos equivalentes no BigQuery. As funções de data e hora do BigQuery incluem funções de data, funções de data/hora, funções de hora e funções de data/hora.

Tenha em atenção que as funções que parecem idênticas no Amazon Redshift e no BigQuery podem devolver tipos de dados 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: os fusos horários são usados ao analisar datas/horas ou formatar datas/horas para apresentação. Uma data/hora formatada como string pode incluir um fuso horário, mas quando o BigQuery analisa a string, armazena a data/hora na hora UTC equivalente. Quando não é especificado explicitamente um fuso horário, é usado o fuso horário predefinido, UTC. Os nomes dos fusos horários ou o desvio do UTC (-HH:MM) são suportados, mas as abreviaturas dos fusos horários (como PDT) não são suportadas.
CONVERT_TIMEZONE(
[source_timezone],
target_timezone,
timestamp
)		 PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamp,
target_timezone
)
)

Nota: source_timezone é UTC no BigQuery.
CURRENT_DATE

Nota: devolve a data de início da transação atual no fuso horário da sessão atual (UTC por predefinição). 		CURRENT_DATE()

Nota: devolve a data de início do extrato atual no fuso horário 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
) 		Para intervalos no Redshift, existem 360 dias num ano. No BigQuery, pode usar a seguinte função definida pelo utilizador (UDF) para analisar um intervalo do Redshift e traduzi-lo em 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 literais de intervalo, execute:

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: devolve a data/hora de início da transação atual no fuso horário da sessão atual (UTC por predefinição). 		CURRENT_TIMESTAMP()

Nota: devolve a data/hora de início do extrato atual no fuso horário 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: o Redshift compara as datas/horas no fuso horário definido pela sessão do utilizador. O fuso horário predefinido da sessão do utilizador é UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Nota: o BigQuery compara as datas/horas no fuso horário UTC.
TIMESTAMPTZ_CMP(
timestamptz1,
timestamptz2
)

Nota: o Redshift compara as datas/horas no fuso horário definido pela sessão do utilizador. O fuso horário predefinido da sessão do utilizador é UTC. 		CASE
WHEN timestamptz1 = timestamptz2
THEN 0
WHEN timestamptz1 > timestamptz2
THEN 1
ELSE -1
END

Nota: o BigQuery compara as datas/horas no fuso horário UTC.
TIMESTAMPTZ_CMP_DATE(
timestamptz,
date
)

Nota: o Redshift compara as datas/horas no fuso horário definido pela sessão do utilizador. O fuso horário predefinido da sessão do utilizador é UTC. 		CASE
WHEN
EXTRACT(
DATE FROM timestamptz) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamptz) > date
THEN 1
ELSE -1
END

Nota: o BigQuery compara as datas/horas no fuso horário UTC.
TIMESTAMPTZ_CMP_TIMESTAMP(
timestamptz,
Timestamp
)

Nota: o Redshift compara as datas/horas no fuso horário definido pela sessão do utilizador. O fuso horário predefinido da sessão do utilizador é UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Nota: o BigQuery compara as datas/horas no fuso horário UTC.
TIMEZONE(
timezone,
Timestamptz_or_timestamp
) 		PARSE_TIMESTAMP(
"%c%z", FORMAT_TIMESTAMP(
"%c%z",
timestamptz_or_timestamp,
timezone
)
)

Nota: os fusos horários são usados ao analisar datas/horas ou formatar datas/horas para apresentação. Uma data/hora formatada como string pode incluir um fuso horário, mas quando o BigQuery analisa a string, armazena a data/hora na hora UTC equivalente. Quando não é especificado explicitamente um fuso horário, é usado o fuso horário predefinido, UTC. Os nomes dos fusos horários ou o desvio do UTC (-HH:MM) são suportados, mas as abreviaturas dos fusos horários (como PDT) não são suportadas.
TO_TIMESTAMP(timestamp, format) PARSE_TIMESTAMP(
format,
FORMAT_TIMESTAMP(
format,
timestamp
)
)

Nota: o BigQuery segue um conjunto diferente de elementos de formato. As zonas horárias são usadas quando se analisam indicações de tempo ou se formatam indicações de tempo para apresentação. Uma data/hora formatada como string pode incluir um fuso horário, mas quando o BigQuery analisa a string, armazena a data/hora na hora UTC equivalente. Quando não é especificado explicitamente um fuso horário, é usado o fuso horário predefinido, UTC. Os nomes dos fusos horários ou o desvio do UTC (-HH:MM) são suportados na string de formato, mas as abreviaturas dos fusos horários (como PDT) não são suportadas.
TRUNC(timestamp) CAST(timestamp AS DATE)

O BigQuery também oferece as seguintes funções de data e hora, que não têm um análogo direto no Amazon Redshift:

Operadores matemáticos

A tabela seguinte mostra os mapeamentos entre operadores matemáticos comuns do Amazon Redshift e os respetivos equivalentes no BigQuery.

Amazon Redshift BigQuery

X + Y

X + Y

X - Y

X - Y

X * Y

X * Y

X / Y


Nota: se o operador estiver
a realizar uma divisão inteira (por outras palavras, se X e Y forem ambos números inteiros), é devolvido um número inteiro. Se o operador estiver a realizar uma divisão não inteira, é devolvido um valor não inteiro.		 Se for divisão inteira:
CAST(FLOOR(X / Y) AS INT64)

Se não for divisão inteira:

CAST(X / Y AS INT64)


Nota: a divisão no BigQuery devolve um valor não inteiro.
Para evitar erros de uma operação de divisão (erro de divisão por zero), use SAFE_DIVIDE(X, Y) ou IEEE_DIVIDE(X, Y).

X % Y

MOD(X, Y)


Nota: para evitar erros de uma operação de divisão (erro de divisão por zero), use SAFE.MOD(X, Y). SAFE.MOD(X, 0) resultados em 0.

X ^ Y

POW(X, Y)

POWER(X, Y)


Nota: ao contrário do Amazon Redshift, o operador ^ no BigQuery executa o xor bit a bit.

| / X

SQRT(X)


Nota: para evitar erros de uma operação de raiz quadrada (entrada negativa), use SAFE.SQRT(X). Entrada negativa com SAFE.SQRT(X) resulta em NULL.

|| / X

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


Nota: a função POWER(X, Y) do BigQuery devolve um erro se X for um valor finito inferior a 0 e Y for um valor não inteiro.

@ X

ABS(X)

X << Y

X << Y


Nota: este operador devolve 0 ou uma sequência de bytes de b'\x00' se o segundo operando Y for superior ou igual ao comprimento de bits do primeiro operando X (por exemplo, 64 se X tiver o tipo INT64). Este operador gera um erro se Y for negativo.

X >> Y

X >> Y


Nota: desloca o primeiro operando X para a direita. Este operador não faz a extensão do bit de sinal com um tipo assinado (preenche os bits vazios à esquerda com 0). Este operador devolve 0 ou uma sequência de bytes de
b'\x00' se o segundo operando Y for maior ou igual ao comprimento em bits do primeiro operando X (por exemplo, 64 se X tiver o tipo INT64). Este operador gera um erro se Y for negativo.

X & Y

X & Y

X | Y

X | Y

~X

~X

O BigQuery também oferece o seguinte operador matemático, que não tem um análogo direto no Amazon Redshift:

Funções 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])

Funções 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: a função CONCAT(...) do BigQuery suporta
a concatenação de qualquer número de strings.
CRC32 Função definida pelo utilizador personalizada
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
)
)

Se position for especificado:

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

Nota: o BigQuery oferece suporte para expressões regulares através da biblioteca re2. Consulte essa documentação para ver a respetiva sintaxe de expressões regulares.
REGEXP_INSTR(
source_string,
pattern
[,position
[,occurrence]] ) 		IFNULL( STRPOS(
source_string, REGEXP_EXTRACT(
source_string,
pattern)
),0)

Se source_string for especificado:

REGEXP_REPLACE(
source_string,

pattern,
replace_string
)

Se position for especificado:

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)

Se occurrence for especificado:

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: o BigQuery oferece
suporte de expressões regulares através da biblioteca re2 ; consulte essa
documentação para ver a sintaxe das expressões
regulares.
REGEXP_REPLACE( source_string,
pattern
[, replace_string [, position]]
) 		REGEXP_REPLACE(
source_string,
pattern,
""
)

Se source_string estiver especificado:

REGEXP_REPLACE(
source_string,

pattern, replace_string
)

Se position estiver especificado:

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
)

Se position for especificado:

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

)

Se occurrence for especificado:

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


pattern
)[SAFE_ORDINAL(occurrence)]

Nota: o BigQuery oferece suporte para expressões regulares através da biblioteca re2. Consulte essa documentação para ver a respetiva sintaxe de expressões 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 ) 		Pode ser implementado através de UDFs:

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)

Funções de formatação do tipo de dados

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: o BigQuery e o Amazon Redshift diferem na forma como especificar uma string de formato para timestamp_expression.
TO_CHAR(
numeric_expression,
format
)		 FORMAT(
format,
numeric_expression
)

Nota: o BigQuery e o Amazon Redshift diferem na forma como especificar uma string de formato para timestamp_expression.
TO_DATE(date_string, format) PARSE_DATE(date_string, format)

Nota: o BigQuery e o Amazon Redshift diferem na forma como especificar uma string de formato para date_string.
TO_NUMBER(string, format) CAST(
FORMAT(
format,
numeric_expression
) TO INT64
)

Nota: o BigQuery e o Amazon Redshift diferem na forma como especificar uma string de formato numérico.

O BigQuery também suporta SAFE_CAST(expression AS typename), que devolve NULL se o BigQuery não conseguir realizar uma conversão; por exemplo, SAFE_CAST("apple" AS INT64) devolve NULL.

Sintaxe DML

Esta secção aborda as diferenças na sintaxe da linguagem de gestão de dados entre o Amazon Redshift e o BigQuery.

INSERT declaração

O Amazon Redshift oferece uma palavra-chave DEFAULT configurável para colunas. No BigQuery, o valor DEFAULT para colunas anuláveis é NULL e DEFAULT não é suportado para colunas obrigatórias. A maioria das declarações do Amazon Redshift é compatível com o BigQuery.INSERT A tabela seguinte mostra as exceções.

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

O BigQuery também suporta a inserção de valores através de uma subconsulta (em que um dos valores é calculado através de uma subconsulta), o que não é suportado no Amazon Redshift. Por exemplo:

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

COPY declaração

O comando COPY do Amazon Redshift carrega dados numa tabela a partir de ficheiros de dados ou de uma tabela do Amazon DynamoDB. O BigQuery não usa o comando SQL COPY para carregar dados, mas pode usar várias ferramentas e opções não SQL para carregar dados para tabelas do BigQuery. Também pode usar os destinos do pipeline de dados fornecidos no Apache Spark ou no Apache Beam para escrever dados no BigQuery.

UPDATE declaração

A maioria das declarações do Amazon Redshift UPDATE é compatível com o BigQuery. A tabela seguinte mostra as exceções.

Amazon Redshift BigQuery
UPDATE table
SET column = expression [,...] [FROM ...] 		UPDATE table
SET column = expression [,...]
[FROM ...]
WHERE TRUE

Nota: todas as declarações UPDATE no BigQuery requerem uma palavra-chave WHERE, seguida de uma condição.
UPDATE table
SET column = DEFAULT [,...] [FROM ...]
[WHERE ...]		 UPDATE table
SET column = NULL [, ...]
[FROM ...]
WHERE ...

Nota: o comando UPDATE do BigQuery não suporta valores DEFAULT.

Se a declaração UPDATE do Amazon Redshift não incluir uma cláusula WHERE, a declaração UPDATE do BigQuery deve ser condicional WHERE TRUE.

DELETE e TRUNCATE extratos

As declarações DELETE e TRUNCATE são formas de remover linhas de uma tabela sem afetar o esquema ou os índices da tabela.

No Amazon Redshift, a declaração TRUNCATE é recomendada em vez de uma declaração DELETE não qualificada porque é mais rápida e não requer operações VACUUM e ANALYZE posteriormente. No entanto, pode usar declarações DELETE para conseguir o mesmo efeito.

No BigQuery, a declaração DELETE tem de ter uma cláusula WHERE. Para mais informações sobre DELETE no BigQuery, consulte os DELETE exemplos do BigQuery na documentação de DML.

Amazon Redshift BigQuery
DELETE [FROM] table_name

TRUNCATE [TABLE] table_name		 DELETE FROM table_name
WHERE TRUE

As declarações do BigQuery requerem uma cláusula DELETE.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 )

No Amazon Redshift, USING permite que sejam feitas referências a tabelas adicionais na cláusula WHERE. Isto pode ser conseguido no BigQuery usando uma subconsulta na cláusula WHERE.

MERGE declaração

A declaração MERGE pode combinar operações INSERT, UPDATE> e DELETE numa única declaração de inserção/atualização e executar as operações de forma atómica. A operação tem de corresponder, no máximo, a uma linha de origem para cada linha de destino.MERGE

O Amazon Redshift não suporta um único comando do MERGE. No entanto, pode executar uma operação de união no Amazon Redshift executando as operações INSERT, UPDATE e DELETE numa transação.

Operação de união através da substituição de linhas existentes

No Amazon Redshift, pode substituir todas as colunas na tabela de destino com uma declaração DELETE e, em seguida, uma declaração INSERT. A declaração DELETE remove as linhas que devem ser atualizadas e, em seguida, a declaração INSERT insere as linhas atualizadas. As tabelas do BigQuery estão limitadas a 1000 declarações DML por dia, pelo que deve consolidar as declarações INSERT, UPDATE e DELETE numa única declaração MERGE, conforme mostrado na tabela seguinte.

Amazon Redshift BigQuery
Consulte o artigo Executar uma operação de união através da substituição de linhas 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: se atualizar todas as colunas, tem de as indicar todas.
Consulte o artigo Realizar uma operação de união especificando uma lista de colunas.

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

Sintaxe DDL

Esta secção aborda as diferenças na sintaxe da linguagem de definição de dados entre o Amazon Redshift e o BigQuery.

SELECT INTO declaração

No Amazon Redshift, a declaração SELECT INTO pode ser usada para inserir os resultados de uma consulta numa nova tabela, combinando a criação e a inserção de tabelas.

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 ... 		O BigQuery oferece várias formas de emular tabelas temporárias. Consulte a secção tabelas temporárias para mais informações.

CREATE TABLE declaração

A maioria das declarações do Amazon Redshift CREATE TABLE é compatível com o BigQuery, exceto os seguintes elementos de sintaxe, que não são usados no 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: as restrições UNIQUE e PRIMARY KEY são informativas e não são aplicadas pelo 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: as restrições UNIQUE e PRIMARY KEY são informativas e não são aplicadas pelo sistema Amazon Redshift. 		CREATE TABLE table_name
(
col1 data_type1[,...]
)
PARTITION BY column_name
CLUSTER BY column_name [, ...]

Nota: o BigQuery não usa restrições de tabelas UNIQUE, PRIMARY KEY nem FOREIGN KEY. Para alcançar uma otimização semelhante à que estas restrições oferecem durante a execução de consultas, crie partições e clusters nas suas tabelas do BigQuery. CLUSTER BY suporta até 4 colunas.
CREATE TABLE table_name
LIKE original_table_name 		Consulte este exemplo para saber como usar as tabelas INFORMATION_SCHEMA para copiar nomes de colunas, tipos de dados e restrições NOT NULL para uma nova tabela.
CREATE TABLE table_name
(
col1 data_type1
)
BACKUP NO

Nota: no Amazon Redshift, a definição BACKUP NO é especificada para poupar tempo de processamento e reduzir o espaço de armazenamento.		 A opção de tabela BACKUP NO não é usada nem necessária porque o BigQuery mantém automaticamente até 7 dias de versões do histórico de todas as suas tabelas sem afetar o tempo de processamento nem o armazenamento faturado.
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 [, ...])] 		O BigQuery suporta o clustering, o que permite armazenar chaves por ordem ordenada.
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
...

O BigQuery também suporta a declaração DDL CREATE OR REPLACE TABLE, que substitui uma tabela se já existir.

A declaração CREATE TABLE do BigQuery também suporta as seguintes cláusulas, que não têm um equivalente no Amazon Redshift:

Para mais informações sobre CREATE TABLE no BigQuery, consulte os CREATE TABLE exemplos na documentação da DML.

Tabelas temporárias

O Amazon Redshift suporta tabelas temporárias, que só são visíveis na sessão atual. Existem várias formas de emular tabelas temporárias no BigQuery:

  • TTL do conjunto de dados: crie um conjunto de dados com um tempo de vida curto (por exemplo, uma hora) para que todas as tabelas criadas no conjunto de dados sejam efetivamente temporárias, uma vez que não persistem mais tempo do que o tempo de vida do conjunto de dados. Pode adicionar o prefixo temp a todos os nomes das tabelas neste conjunto de dados para indicar claramente que as tabelas são temporárias.

  • TTL da tabela: crie uma tabela com um tempo de vida curto específico da tabela usando declarações DDL semelhantes às seguintes:

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

CREATE VIEW declaração

A tabela seguinte mostra os equivalentes entre o Amazon Redshift e o BigQuery para a declaração 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 ...
Não suportado. CREATE VIEW IF NOT EXISTS c view_name
OPTIONS(view_option_list)
AS SELECT …

Cria uma nova visualização de propriedade apenas se a visualização de propriedade não existir no conjunto de dados especificado.
CREATE VIEW view_name
AS SELECT ...
WITH NO SCHEMA BINDING

No Amazon Redshift, é necessária uma vista de associação tardia para fazer referência a uma tabela externa.		 No BigQuery, para criar uma vista, todos os objetos referenciados têm de existir.

O BigQuery permite-lhe consultar origens de dados externas.

Funções definidas pelo utilizador (FDUs)

Uma FDU permite-lhe criar funções para operações personalizadas. Estas funções aceitam colunas de entrada, realizam ações e devolvem o resultado dessas ações como um valor.

Tanto o Amazon Redshift como o BigQuery suportam UDFs através de expressões SQL. Além disso, no Amazon Redshift, pode criar uma UDF baseada em Python e, no BigQuery, pode criar uma UDF baseada em JavaScript.

Consulte o repositório do GitHub de utilitários do Google Cloud BigQuery para aceder a uma biblioteca de UDFs comuns do BigQuery.

Sintaxe CREATE FUNCTION

A tabela seguinte aborda as diferenças na sintaxe de criação de UDFs SQL entre o Amazon Redshift e o 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: numa UDF SQL do BigQuery, um tipo de dados de retorno é opcional. O BigQuery infere o tipo de resultado da função a partir do corpo da função SQL quando uma consulta chama a função.
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: a volatilidade da função não é um parâmetro configurável no BigQuery. Toda a volatilidade da UDF do BigQuery é equivalente à volatilidade do Amazon Redshift (ou seja, não faz pesquisas na base de dados nem usa informações que não estejam diretamente presentes na respetiva lista de argumentos).IMMUTABLE
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
SELECT_clause
$$ LANGUAGE sql

Nota: o Amazon Redshift suporta apenas uma cláusula SQL SELECT como definição de função. Além disso, a cláusula SELECT não pode incluir nenhuma das cláusulas FROM, INTO, WHERE, GROUP BY, ORDER BY, e LIMIT. 		CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
AS sql_expression

Nota: o BigQuery suporta quaisquer expressões SQL como definição de função. No entanto, não é possível fazer referência a tabelas, vistas ou 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: não é necessário especificar o literal de idioma numa UDF do GoogleSQL. O BigQuery interpreta a expressão SQL por predefinição. Além disso, o Amazon Redshift usa as aspas duplas ($$) 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 o início e o fim das declarações de funções.

Para UDFs de SQL,o Amazon Redshift suporta apenas uma SELECT cláusula SQL como a definição da função. Além disso, a cláusula SELECT não pode incluir nenhuma das cláusulas FROM, INTO, WHERE, GROUP,
, BY, ORDER BY e LIMIT .

Para UDFs do Python, pode escrever um programa Python usando a biblioteca padrão do Python 2.7 ou importar os seus módulos personalizados criando um com o comando CREATE LIBRARY .		 No BigQuery, tem de colocar o código JavaScript entre aspas. Consulte as regras de citação para mais informações.

Para FDUs SQL, pode usar quaisquer expressões SQL como definição da função. No entanto, o BigQuery não suporta referências a tabelas, vistas nem modelos.

Para UDFs JavaScript, pode incluir bibliotecas de código externas diretamente através da secção OPTIONS . Também pode usar a ferramenta de teste UDF do BigQuery para testar as suas funções.
Idioma Tem de usar o literal LANGUAGE para especificar o idioma como sql para FDUs SQL ou plpythonu para FDUs Python. Não tem de especificar LANGUAGE para FDUs SQL, mas tem de especificar o idioma como js para FDUs JavaScript.
Estado O Amazon Redshift não suporta a criação de UDFs temporárias.

O Amazon Redshift oferece uma opção para definir a volatilidade de uma função através de VOLATILE, STABLE, ou literais IMMUTABLE . Isto é usado para otimização pelo otimizador de consultas.		 O BigQuery suporta UDFs persistentes e temporárias. Pode reutilizar FDUs persistentes em várias consultas, enquanto só pode usar FDUs temporárias numa única consulta.

A volatilidade da função não é um parâmetro configurável no BigQuery. Toda a volatilidade das UDFs do BigQuery é equivalente à IMMUTABLE volatilidade do Amazon Redshift.
Segurança e privilégios Para criar uma FDU, tem de ter autorização para utilização na linguagem para SQL ou plpythonu (Python). Por predefinição, USAGE ON LANGUAGE SQL é concedido a PUBLIC, mas tem de conceder explicitamente USAGE ON LANGUAGE PLPYTHONU a utilizadores ou grupos específicos.
Além disso, tem de ser um superutilizador para substituir uma FDU.		 Não é necessário conceder autorizações explícitas para criar ou eliminar qualquer tipo de UDF no BigQuery. Qualquer utilizador ao qual seja atribuída a função de editor de dados do BigQuery (com bigquery.routines.* como uma das autorizações) pode criar ou eliminar funções para o conjunto de dados especificado.

O BigQuery também suporta a criação de funções personalizadas. Pode gerir esta opção com o Cloud IAM.
Limites Consulte os limites das UDFs do Python. Consulte os limites das funções definidas pelo utilizador.

Metadados e declarações SQL de transações

Amazon Redshift BigQuery
SELECT * FROM STL_ANALYZE WHERE name
= 'T';		 Não usado no BigQuery. Não precisa de recolher estatísticas para melhorar o desempenho das consultas. Para obter informações sobre a distribuição dos seus dados, pode usar funções agregadas aproximadas.
ANALYZE [[ table_name[(column_name
[, ...])]]		 Não usado no BigQuery.
LOCK TABLE table_name; Não usado no BigQuery.
BEGIN TRANSACTION; SELECT ...
END TRANSACTION;		 O BigQuery usa o isolamento de instantâneos. Para ver detalhes, consulte as garantias de consistência.
EXPLAIN ... Não usado no BigQuery.

Funcionalidades semelhantes são a explicação do plano de consulta na consola do BigQuery Trusted Cloud e o registo de auditoria no Cloud Monitoring.
SELECT * FROM SVV_TABLE_INFO WHERE
table = 'T';		 SELECT * EXCEPT(is_typed) FROM
mydataset.INFORMATION_SCHEMA.TABLES;

Para mais informações, consulte o artigo Introdução ao BigQuery INFORMATION_SCHEMA.
VACUUM [table_name] Não usado no BigQuery. As tabelas agrupadas do BigQuery são ordenadas automaticamente.

Declarações SQL multilinhas e com várias declarações

O Amazon Redshift e o BigQuery suportam transações (sessões) e, por isso, suportam declarações separadas por pontos e vírgulas que são executadas de forma consistente em conjunto. Para mais informações, consulte o artigo Transações com vários extratos.

Declarações SQL processuais

CREATE PROCEDURE declaração

Amazon Redshift BigQuery
CREATE or REPLACE PROCEDURE CREATE PROCEDURE se for necessário um nome.

Caso contrário, use o formato inline com BEGIN ou numa única linha com CREATE TEMP FUNCTION.
CALL CALL

Declaração e atribuição de variáveis

Amazon Redshift BigQuery
DECLARE DECLARE

Declara uma variável do tipo especificado.
SET SET

Define uma variável para ter o valor da expressão fornecida ou define várias variáveis ao mesmo tempo com base no resultado de várias expressões.

Controladores de condições de erro

No Amazon Redshift, um erro encontrado durante a execução de um procedimento armazenado termina o fluxo de execução, termina a transação e reverte a transação. Estes resultados ocorrem porque as subtransações não são suportadas. Num procedimento armazenado do Amazon Redshift, o único handler_statement suportado é RAISE. No BigQuery, o processamento de erros é uma funcionalidade essencial do fluxo de controlo principal, semelhante ao que outras linguagens oferecem com blocos 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;

Declarações e operações do cursor

Uma vez que o BigQuery não suporta cursores nem sessões, as seguintes declarações não são usadas no BigQuery:

Se estiver a usar o cursor para devolver um conjunto de resultados, pode obter um comportamento semelhante usando tabelas temporárias no BigQuery.

Declarações SQL dinâmicas

A funcionalidade de scripts no BigQuery suporta declarações SQL dinâmicas, como as apresentadas na tabela seguinte.

Amazon Redshift BigQuery
EXECUTE EXECUTE IMMEDIATE

Declarações de fluxo de controlo

Amazon Redshift BigQuery
IF..THEN..ELSIF..THEN..ELSE..END IF IF condition
THEN stmts
ELSE stmts
END IF
name CURSOR [ ( arguments ) ] FOR query Não são usados cursores nem sessões no BigQuery.
[< LOOP
sql_statement_list END LOOP;
WHILE condition LOOP stmts END LOOP WHILE condition
DO stmts
END WHILE
EXIT BREAK

Garantias de consistência e isolamento de transações

O Amazon Redshift e o BigQuery são atómicos, ou seja, estão em conformidade com ACID ao nível de cada mutação em várias linhas.

Transações

O Amazon Redshift suporta o isolamento serializável por predefinição para transações. O Amazon Redshift permite-lhe especificar qualquer um dos quatro níveis de isolamento de transações padrão SQL, mas processa todos os níveis de isolamento como serializáveis.

O BigQuery também suporta transações. O BigQuery ajuda a garantir o controlo de concorrência otimista (a primeira confirmação tem prioridade) com isolamento de instantâneo, em que uma consulta lê os últimos dados confirmados antes de começar. Esta abordagem garante o mesmo nível de consistência por linha, por mutação e entre linhas na mesma declaração DML, mas evita bloqueios. No caso de várias atualizações de DML na mesma tabela, o BigQuery muda para o controlo de concorrência pessimista. Os trabalhos de carregamento podem ser executados de forma totalmente independente e anexados a tabelas.

Reversão

Se o Amazon Redshift encontrar algum erro durante a execução de um procedimento armazenado, reverte todas as alterações feitas numa transação. Além disso, pode usar a declaração de controlo de transações ROLLBACK num procedimento armazenado para rejeitar todas as alterações.

No BigQuery, pode usar a declaração ROLLBACK TRANSACTION.

Limites da base de dados

Consulte a documentação pública do BigQuery para ver as quotas e os limites mais recentes. Muitas quotas para utilizadores de grande volume podem ser aumentadas contactando a equipa de apoio técnico do Google Cloud. A tabela seguinte mostra uma comparação dos limites da base de dados do Amazon Redshift e do BigQuery.

Limite Amazon Redshift BigQuery
Tabelas em cada base de dados para tipos de nós de cluster grandes e extragrandes 9900 Sem restrições
Tabelas em cada base de dados para tipos de nós de cluster 8xlarge 20 000 Sem restrições
Bases de dados definidas pelo utilizador que pode criar para cada cluster 60 Sem restrições
Tamanho máximo da linha 4 MB 100 MB