Guia de tradução do SQL do Amazon Redshift

Este documento detalha as semelhanças e diferenças da sintaxe SQL entre o Amazon Redshift e o BigQuery para ajudar você a planejar sua migração. Use a tradução do SQL em lote para migrar os scripts SQL em massa ou a tradução interativa do SQL para traduzir consultas ad-hoc.

O público-alvo deste guia são arquitetos empresariais, administradores de bancos de dados, desenvolvedores de aplicativos e especialistas em segurança de TI. Este guia supõe que você esteja familiarizado com o Amazon Redshift.

Tipos de dados

Nesta seção, são mostrados a equivalência entre os tipos de dados no Amazon Redshift e no BigQuery.

Amazon Redshift BigQuery Observações
Tipo de dado Alias Tipo de dado
SMALLINT INT2 INT64 O SMALLINT do Amazon Redshift é de 2 bytes, enquanto o INT64 do BigQuery é de 8 bytes.
INTEGER

INT, INT4

 INT64 O INTEGER do Amazon Redshift é de 4 bytes, enquanto o INT64 do BigQuery é de 8 bytes.
BIGINT INT8 INT64 Tanto o BIGINT do Amazon Redshift quanto o INT64 do BigQuery são de 8 bytes.
DECIMAL NUMERIC NUMERIC
REAL FLOAT4 FLOAT64 O REAL do Amazon Redshift é de 4 bytes, enquanto o FLOAT64 do BigQuery é de 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 dado BOOL do BigQuery usa TRUE, que não diferencia maiúsculas de minúsculas.
CHAR

CHARACTER, NCHAR, BPCHAR

STRING
VARCHAR

CHARACTER VARYING, NVARCHAR, TEXT

STRING
DATE DATE
TIMESTAMP TIMESTAMP WITHOUT TIME ZONE DATETIME
TIMESTAMPTZ

TIMESTAMP WITH TIME ZONE

TIMESTAMP Observação: no BigQuery, os fusos horários são usados ao analisar ou formatar carimbos de data/hora para exibição. Um carimbo de data/hora formatado pela string pode incluir um fuso horário, mas quando o BigQuery analisa a string, ele armazena o carimbo de data/hora no horário UTC equivalente. Quando um fuso horário não for especificado explicitamente, será utilizado o fuso horário padrão, que é UTC. Nomes de fuso horário oudiferença de UTC utilizando (-|+)HH:MM são compatíveis, mas as abreviações de fuso horário, como PDT, não.
GEOMETRY GEOGRAPHY Suporte para consulta de dados geoespaciais.

Os seguintes tipos de dados do BigQuery também não têm análogos diretos no Amazon Redshift:

Tipos de conversão implícitos

Ao migrar para o BigQuery, você precisa converter a maioria das suas conversões implícitas do Amazon Redshift para conversões explícitas do BigQuery, exceto no caso dos tipos de dados a seguir, que são convertidos implicitamente pelo BigQuery.

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

Do tipo do BigQuery Para o tipo do BigQuery

INT64

FLOAT64

INT64

NUMERIC

NUMERIC

FLOAT64

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

Do tipo do 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

É possível converter os 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 DATE e TIMESTAMP.

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

Sintaxe das consultas

Nesta seção, são abordadas as diferenças entre o Amazon Redshift e o BigQuery no que diz respeito à sintaxe das consultas.

Instrução SELECT

A maioria das instruções SELECT do Amazon Redshift são compatíveis com o BigQuery. A tabela a seguir mostra uma lista de pequenas diferenças.

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

Observação: o Redshift é compatível com a criação e referência a um alias na mesma instrução SELECT.

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

O BigQuery também oferece suporte às seguintes expressões nas instruções SELECT, que não têm um equivalente no Amazon Redshift:

Cláusula FROM

Uma cláusula FROM em uma consulta lista as referências da tabela de onde os dados são selecionados. No Amazon Redshift, as referências da tabela possíveis incluem tabelas, visualizações e subconsultas. Todas essas referências de tabela são compatíveis com o BigQuery.

É possível consultar as tabelas do BigQuery na cláusula FROM usando o seguinte:

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

O BigQuery também oferece suporte a outras referências de tabela:

Tipos JOIN

Tanto o Amazon Redshift quanto o BigQuery são compatíveis com os seguintes tipos de mesclagem:

A tabela a seguir mostra 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 [, ...])


Observação: no BigQuery, as cláusulas JOIN exigem uma JOIN condição, a menos que a cláusula seja uma CROSS JOIN ou uma das tabelas mescladas seja um campo em um tipo de dado ou uma matriz.

Cláusula WITH

Uma cláusula WITH do BigQuery contém uma ou mais subconsultas nomeadas que são executadas quando uma instrução SELECT subsequente se refere a elas. As cláusulas WITH do Amazon Redshift se comportam da mesma forma que as do BigQuery, com a exceção de que é possível avaliar a cláusula uma vez e reutilizar seus resultados.

Operadores de conjunto

Há algumas pequenas diferenças entre os Operadores de conjunto do Amazon Redshift e os Operadores de conjunto do BigQuery. No entanto, todas as operações de conjunto viáveis no Amazon Redshift podem ser replicadas no BigQuery.

Amazon Redshift BigQuery

SELECT * FROM table1
UNION
SELECT * FROM table2

SELECT * FROM table1
UNION DISTINCT
SELECT * FROM table2

Observação: tanto o BigQuery quanto o Amazon Redshift são compatíveis com 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
)


Observação: o BigQuery exige parênteses para separar operações de conjunto diferentes. Se a mesma operação de conjunto for repetida, os parênteses não serão necessários.

Cláusula ORDER BY

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

Amazon Redshift BigQuery
No Amazon Redshift, os NULLs são classificados por último, por padrão (ordem crescente). Já no BigQuery, os NULLs vêm primeiro na classificação, por padrão (ordem crescente).

SELECT *
FROM table
ORDER BY expression
LIMIT ALL

SELECT *
FROM table
ORDER BY expression



Observação: o BigQuery não usa a sintaxe LIMIT ALL, mas ORDER BY classifica todas as linhas por padrão, resultando no mesmo comportamento que a cláusula LIMIT ALL do Amazon Redshift. É altamente recomendável incluir uma cláusula LIMIT em todas as cláusulas ORDER BY. Ordenar todas as linhas de resultados desnecessariamente reduz o desempenho de execução da consulta.

SELECT *
FROM table
ORDER BY expression
OFFSET 10

SELECT *
FROM table
ORDER BY expression
LIMIT count OFFSET 10



Observação: no BigQuery, OFFSET precisa ser usado com uma contagem LIMIT. Defina o valor contagem INT64 como o número mínimo necessário de linhas ordenadas. Ordenar todas as linhas de resultados
desnecessariamente reduz o desempenho de execução das consultas.

Condições

A tabela a seguir mostra as condições do Amazon Redshift, ou predicados, que são específicas do Amazon Redshift e precisam ser convertidas a seus 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


Observação: o BigQuery não oferece suporte a caracteres de escape personalizados. É preciso usar duas barras invertidas \\ como caracteres de escape no BigQuery.

expression [NOT] SIMILAR TO pattern

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


Observação: se NOT for especificado, resuma a expressão IF acima em uma expressão NOT, conforme mostrado abaixo:

NOT(
IF(
LENGTH(...
)

expression [!] ~ pattern

[NOT] REGEXP_CONTAINS(
expression,
regex
)

Funções

As seções a seguir listam as funções do Amazon Redshift e suas equivalentes no BigQuery.

Funções de agregação

A tabela a seguir mostra os mapeamentos entre as funções de agregação, agregação analítica e agregação aproximada do Amazon Redshift e as suas 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()

Observação: não aborda casos de uso 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 análogos diretos no Amazon Redshift:

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

A tabela a seguir mostra os mapeamentos entre funções comuns de agregação bit a bit do Amazon Redshift e as suas equivalentes no BigQuery.

Amazon Redshift BigQuery
BIT_AND(expression) BIT_ADD(expression)
BIT_OR(expression) BIT_OR(expression)
BOOL_AND>(expression) LOGICAL_AND(expression)
BOOL_OR(expression) LOGICAL_OR(expression)

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 a seguir mostra mapeamentos entre funções comuns de janela do Amazon Redshift e as suas equivalentes no BigQuery. As funções de janela no BigQuery incluem funções de agregação analítica, 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 a seguir mostra mapeamentos entre expressões condicionais comuns do Amazon Redshift e suas equivalentes no 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 a seguir mostra mapeamentos entre funções comuns de data e hora do Amazon Redshift e seus 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 carimbo de data/hora.

Tenha em mente que funções do Amazon Redshift e do BigQuery que parecem idênticas podem retornar 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
)
)

Observação: fusos horários são usados na análise ou formatação dos carimbos de data/hora para exibição. Um carimbo de data/hora formatado pela string pode incluir um fuso horário, mas quando o BigQuery analisa a string, ele armazena o carimbo de data/hora no horário UTC equivalente. Quando um fuso horário não for especificado explicitamente, será utilizado o fuso horário padrão, que é UTC. Nomes de fuso horário ou diferença de UTC (-HH:MM) são suportados, mas as abreviações de fuso horário, como PDT, não são.
CONVERT_TIMEZONE(
[source_timezone],
target_timezone,
timestamp
)		 PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamp,
target_timezone
)
)

Observação: source_timezone é UTC no BigQuery.
CURRENT_DATE

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

Observação: retorna a data de início da instrução 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
) 		No Redshift, há 360 dias em um ano para intervalos. No BigQuery, é possível usar a seguinte função definida pelo usuário (UDF) para analisar um intervalo do Redshift e convertê-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 os literais de intervalo, faça o seguinte:

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

Observação: retorna o carimbo de data/hora de início da transação atual no fuso horário da sessão atual (UTC por padrão). 		CURRENT_TIMESTAMP()

Observação: retorna o carimbo de data/hora de início da instrução 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
)

Observação: o Redshift compara carimbos de data/hora no fuso horário definido pela sessão do usuário. O fuso horário padrão da sessão do usuário é UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Observação: o BigQuery compara carimbos de data/hora no fuso horário UTC.
TIMESTAMPTZ_CMP(
timestamptz1,
timestamptz2
)

Observação: o Redshift compara carimbos de data/hora no fuso horário definido pela sessão do usuário. O fuso horário padrão da sessão do usuário é UTC. 		CASE
WHEN timestamptz1 = timestamptz2
THEN 0
WHEN timestamptz1 > timestamptz2
THEN 1
ELSE -1
END

Observação: o BigQuery compara carimbos de data/hora no fuso horário UTC.
TIMESTAMPTZ_CMP_DATE(
timestamptz,
date
)

Observação: o Redshift compara carimbos de data/hora no fuso horário definido pela sessão do usuário. O fuso horário padrão da sessão do usuário é UTC. 		CASE
WHEN
EXTRACT(
DATE FROM timestamptz) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamptz) > date
THEN 1
ELSE -1
END

Observação: o BigQuery compara carimbos de data/hora no fuso horário UTC.
TIMESTAMPTZ_CMP_TIMESTAMP(
timestamptz,
Timestamp
)

Observação: o Redshift compara carimbos de data/hora no fuso horário definido pela sessão do usuário. O fuso horário padrão da sessão do usuário é UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Observação: o BigQuery compara carimbos de data/hora no fuso horário UTC.
TIMEZONE(
timezone,
Timestamptz_or_timestamp
) 		PARSE_TIMESTAMP(
"%c%z", FORMAT_TIMESTAMP(
"%c%z",
timestamptz_or_timestamp,
timezone
)
)

Observação: fusos horários são usados na análise ou formatação dos carimbos de data/hora para exibição. Um carimbo de data/hora formatado pela string pode incluir um fuso horário, mas quando o BigQuery analisa a string, ele armazena o carimbo de data/hora no horário UTC equivalente. Quando um fuso horário não for especificado explicitamente, será utilizado o fuso horário padrão, que é UTC. Nomes de fuso horário ou diferença de UTC (-HH:MM) são suportados, mas as abreviações de fuso horário, como PDT, não são.
TO_TIMESTAMP(timestamp, format) PARSE_TIMESTAMP(
format,
FORMAT_TIMESTAMP(
format,
timestamp
)
)

Observação: o BigQuery segue um conjunto diferente de elementos de formato. Fusos horários são usados na análise ou formatação de carimbos de data/hora para exibição. Um carimbo de data/hora formatado pela string pode incluir um fuso horário, mas quando o BigQuery analisa a string, ele armazena o carimbo de data/hora no horário UTC equivalente. Quando um fuso horário não for especificado explicitamente, será utilizado o fuso horário padrão, que é UTC. Nomes de fusos horários ou diferença de UTC (-HH:MM) são suportado na string de formato, mas as abreviações de fuso horário (como PDT) não são.
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 a seguir mostra mapeamentos entre operadores matemáticos comuns do Amazon Redshift e seus equivalentes no BigQuery.

Amazon Redshift BigQuery

X + Y

X + Y

X - Y

X - Y

X * Y

X * Y

X / Y


Observação: se o operador estiver
realizando uma divisão de números inteiros (em outras palavras, se X e Y forem números inteiros), o resultado será um número inteiro. Se o operador estiver realizando uma divisão com números não inteiros, o resultado será um número não inteiro.		 Se a divisão de número inteiro:
CAST(FLOOR(X / Y) AS INT64)

Se a divisão de número não inteiro:

CAST(X / Y AS INT64)


Observação: o resultado da divisão no BigQuery é um número não inteiro.
Para evitar erros causados por 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)


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

X ^ Y

POW(X, Y)

POWER(X, Y)


Observação: diferentemente do Amazon Redshift, o operador ^ no BigQuery executa o bit a bit xor.

| / X

SQRT(X)


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

|| / X

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


Observação: o POWER(X, Y) do BigQuery retornará um erro se X for um valor finito menor que 0 e Y for um número não inteiro.

@ X

ABS(X)

X << Y

X << Y


Observação: esse operador retorna 0 ou uma sequência de bytes de b'\x00' se o segundo operando, Y, for maior ou igual ao comprimento do bit do primeiro operando, X, (por exemplo, 64, se X tiver o tipo INT64). Esse operador gerará um erro se Y for negativo.

X >> Y

X >> Y


Observação: desloca o primeiro operando X para a direita. Esse operador não faz a extensão de bit de sinal com um tipo com sinal. Isso significa que ele preenche com 0 os bits vagos à esquerda. Esse operador retorna 0 ou uma sequência de bytes de
b'\x00' se o segundo operando, Y, for maior ou igual ao comprimento do bit do primeiro operando, X, (por exemplo, 64, se X tiver o tipo INT64). Esse operador gerará 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)

Observação: o CONCAT(...) do BigQuery oferece suporte à
concatenação de qualquer número de strings.
CRC32 Função definida pelo usuário 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
)
)

Observação: o BigQuery oferece suporte a expressões regulares usando a biblioteca re2. Consulte a documentação correspondente para ver a 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 está especificado:

REGEXP_REPLACE(
source_string,

pattern,
replace_string
)

Se position está 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 está 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)

Observação: o BigQuery fornece suporte a expressões regulares
usando a biblioteca re2. Consulte a
documentação para ver a sintaxe de expressões regulares
.
REGEXP_REPLACE( source_string,
pattern
[, replace_string [, position]]
) 		REGEXP_REPLACE(
source_string,
pattern,
""
)

Se source_string está especificado:

REGEXP_REPLACE(
source_string,

pattern, replace_string
)

Se position está 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 está especificado:

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

)

Se occurrence está especificado:

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


pattern
)[SAFE_ORDINAL(occurrence)]

Observação: o BigQuery oferece suporte a expressões regulares usando a biblioteca re2. Consulte a documentação para ver a 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 usando 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
)

Observação: o BigQuery e o Amazon Redshift agem de forma diferente ao especificar uma string de formato para timestamp_expression.
TO_CHAR(
numeric_expression,
format
)		 FORMAT(
format,
numeric_expression
)

Observação: o BigQuery e o Amazon Redshift agem de forma diferente ao especificar uma string de formato para timestamp_expression.
TO_DATE(date_string, format) PARSE_DATE(date_string, format)

Observação: o BigQuery e o Amazon Redshift agem de forma diferente ao especificar uma string de formato para date_string.
TO_NUMBER(string, format) CAST(
FORMAT(
format,
numeric_expression
) TO INT64
)

Observação: o BigQuery e o Amazon Redshift agem de forma diferente ao especificar uma string de formato numérico.

O BigQuery também oferece suporte a SAFE_CAST(expression AS typename), cujo resultado será NULL se o BigQuery não conseguir realizar uma transmissão. Por exemplo, o resultado de SAFE_CAST("apple" AS INT64) é NULL.

Sintaxe DML

Nesta seção, são abordadas as diferenças na sintaxe da linguagem de gerenciamento de dados entre o Amazon Redshift e o BigQuery.

Instrução INSERT

O Amazon Redshift oferece uma palavra-chave DEFAULT configurável para colunas. No BigQuery, o valor DEFAULT das colunas anuláveis é NULL, e DEFAULT não é compatível com colunas obrigatórias. A maioria das instruções INSERT do Amazon Redshift é compatível com o BigQuery. A tabela a seguir 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 oferece suporte à inserção de valores usando uma subconsulta, em que um dos valores é calculado usando uma subconsulta, o que não é possível no Amazon Redshift. Exemplo:

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

Instrução COPY

O comando COPY do Amazon Redshift carrega dados em uma tabela a partir de arquivos de dados ou de uma tabela do Amazon DynamoDB. O BigQuery não usa o comando SQL COPY para carregar dados, mas é possível usar qualquer uma das várias ferramentas e opções que não são do SQL para carregar dados nas tabelas do BigQuery. Também é possível usar os coletores de data pipelines fornecidos no Apache Spark ou no Apache Beam para gravar dados no BigQuery.

Instrução UPDATE

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

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

Observação: todas as instruções UPDATE no BigQuery exigem uma palavra-chave WHERE, seguida por uma condição.
UPDATE table
SET column = DEFAULT [,...] [FROM ...]
[WHERE ...]		 UPDATE table
SET column = NULL [, ...]
[FROM ...]
WHERE ...

Observação: o comando UPDATE do BigQuery não é compatível com valores DEFAULT.

Se a instrução UPDATE do Amazon Redshift não incluir uma cláusula WHERE, a instrução UPDATE do BigQuery precisará ser condicionada à WHERE TRUE.

Declarações DELETE e TRUNCATE.

As instruções DELETE e TRUNCATE são maneiras de remover linhas de uma tabela sem afetar seu esquema ou índices.

No Amazon Redshift, a instrução TRUNCATE é recomendada no lugar de uma instrução DELETE não qualificada porque é mais rápida e não precisa das operações VACUUM e ANALYZE posteriormente. No entanto, é possível usar as instruções DELETE para ter o mesmo efeito.

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

Amazon Redshift BigQuery
DELETE [FROM] table_name

TRUNCATE [TABLE] table_name		 DELETE FROM table_name
WHERE TRUE

As instruções DELETE do BigQuery exigem uma 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 )

No Amazon Redshift, o USING permite a referência a outras tabelas na cláusula WHERE. Isso pode ser feito no BigQuery usando uma subconsulta na cláusula WHERE.

Instrução MERGE

A instrução MERGE pode combinar operações INSERT, UPDATE e DELETE em uma única instrução upsert e executar as operações de maneira atômica. A operação MERGE precisa corresponder, no máximo, a uma linha de origem para cada linha de destino.

O Amazon Redshift não oferece suporte a um comando MERGE único. No entanto, uma operação de mesclagem pode ser realizada no Amazon Redshift executando as operações INSERT, UPDATE e DELETE em uma transação.

Operação de mesclagem substituindo as linhas existentes

No Amazon Redshift, uma substituição de todas as colunas na tabela de destino pode ser feita usando uma instrução DELETE e uma instrução INSERT. A instrução DELETE remove as linhas que precisam de atualização e, em seguida, a instrução INSERT insere as linhas atualizadas. As tabelas do BigQuery têm um limite de 1.000 instruções DML por dia. Por isso, você precisa consolidar as instruções INSERT, UPDATE e DELETE em uma instrução MERGE única, conforme mostrado na tabela a seguir.

Amazon Redshift BigQuery
Consulte Como executar uma operação de mesclagem substituindo 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,
...

Observação: se todas as colunas estiverem sendo atualizadas, todas precisarão ser listadas.
Consulte Como executar uma operação de mesclagem 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

Nesta seção, são abordadas as diferenças na sintaxe da linguagem de definição de dados entre o Amazon Redshift e o BigQuery.

Instrução SELECT INTO

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

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 maneiras de emular tabelas temporárias. Consulte a seção Tabelas temporárias para obter mais informações.

Instrução CREATE TABLE

A maioria das instruções CREATE TABLE do Amazon Redshift são compatíveis com o BigQuery, exceto pelos 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
)

Observação: as restrições UNIQUE e PRIMARY KEY são informativas e não são aplicadas pelo sistema do 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)]

Observação: as restrições UNIQUE e PRIMARY KEY são informativas e não são aplicadas pelo sistema do Amazon Redshift. 		CREATE TABLE table_name
(
col1 data_type1[,...]
)
PARTITION BY column_name
CLUSTER BY column_name [, ...]

Observação: o BigQuery não usa as restrições de tabela UNIQUE, PRIMARY KEY ou FOREIGN KEY. Para alcançar uma otimização semelhante à fornecida por essas restrições durante a execução da consulta, particione e agrupe suas tabelas do BigQuery. CLUSTER BY oferece suporte a até quatro 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 em uma nova tabela.
CREATE TABLE table_name
(
col1 data_type1
)
BACKUP NO

Observação: no Amazon Redshift, a configuração BACKUP NO é especificada para poupar o tempo gasto no 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é sete dias de versões históricas de todas as tabelas, sem qualquer efeito adverso sobre o tempo de processamento ou o armazenamento faturados.
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 oferece suporte ao clustering, que permite armazenar chaves em uma ordem classificada.
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 oferece suporte à instrução DDL CREATE OR REPLACE TABLE, que substitui uma tabela já existente.

A instrução CREATE TABLE do BigQuery também é compatível com 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 exemplos de CREATE TABLE do BigQuery na documentação do DML.

Tabelas temporárias

O Amazon Redshift é compatível com tabelas temporárias, que são visíveis apenas na sessão atual. Há várias maneiras de emular tabelas temporárias no BigQuery:

  • Tempo de vida (TTL) do conjunto de dados: crie um conjunto de dados que tenha um curto tempo de vida, por exemplo, uma hora, para que as tabelas criadas no conjunto de dados sejam efetivamente temporárias, já que não permanecerão por mais tempo do que o tempo de vida do conjunto de dados. É possível prefixar todos os nomes de tabela nesse conjunto de dados com "temp" para indicar claramente que as tabelas são temporárias.

  • Tempo de vida (TTL) da tabela: crie uma tabela que tenha um curto tempo de vida específico usando instruções DDL semelhantes a estas:

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

Instrução CREATE VIEW

A tabela a seguir mostra equivalentes entre o Amazon Redshift e o BigQuery para a instrução CREATE VIEW.

Amazon Redshift BigQuery
CREATE VIEW view_name AS SELECT ...código> 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 ...
Incompatível. CREATE VIEW IF NOT EXISTS c view_name
OPTIONS(view_option_list)
AS SELECT …

criará uma nova visualização somente se ela não existir no conjunto de dados especificado.
CREATE VIEW view_name
AS SELECT ...
WITH NO SCHEMA BINDING

No Amazon Redshift, é necessário ter uma visualização de vinculação tardia para fazer referência a uma tabela externa.		 Para criar uma visualização no BigQuery, é necessário que todos os objetos referenciados já existam.

O BigQuery permite consultar fontes de dados externas.

Funções definidas pelo usuário (UDFs)

Uma UDF permite criar funções para operações personalizadas. Essas funções aceitam colunas de entrada, executam ações e mostram o resultado dessas ações como um valor.

Tanto o Amazon Redshift quanto o BigQuery oferecem suporte a UDFs usando expressões SQL. Além disso, no Amazon Redshift, é possível criar uma UDF baseada em Python e, no BigQuery, uma UDF baseada em JavaScript.

Consulte o repositório do GitHub de utilitários do BigQuery do Google Cloud, onde há uma biblioteca de UDFs comuns do BigQuery.

Sintaxe CREATE FUNCTION

A tabela a seguir mostra as diferenças na sintaxe de criação de UDF do 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

Observação: em uma UDF do 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 do 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

Observação: a volatilidade de função não é um parâmetro configurável no BigQuery. Toda a volatilidade de UDF no BigQuery é equivalente à volatilidade de IMMUTABLE do Amazon Redshift. Ou seja, ele não faz pesquisas no banco de dados nem usa informações que não estejam diretamente presentes na 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

Observação: o Amazon Redshift oferece suporte apenas a 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

Observação: o BigQuery oferece suporte a qualquer expressão SQL como definição de função. No entanto, não é possível se referir a tabelas, visualizações 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

Observação: o literal de linguagem não precisa ser especificado em uma UDF do GoogleSQL. O BigQuery interpreta a expressão do SQL por padrão. Além disso, a cota de dólar do Amazon Redshift ($$) não é compatível com o 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

Observação: as UDFs do BigQuery exigem que todos os argumentos de entrada sejam nomeados. As variáveis de argumento do Amazon Redshift ($1, $2, ...) não são compatíveis com o BigQuery.
CREATE [OR REPLACE] FUNCTION
function_name
(integer, integer)
RETURNS integer
IMMUTABLE
AS $$
SELECT $1 + $2
$$ LANGUAGE sql

Observação: o Amazon Redshift não é compatível com ANY TYPE para UDFs do SQL. No entanto, ele oferece suporte ao uso do tipo de dados ANYELEMENT em UDFs baseadas em Python. 		CREATE [OR REPLACE] FUNCTION
function_name
(x ANY TYPE, y ANY TYPE)
AS
SELECT x + y

Observação: o BigQuery oferece suporte ao uso de ANY TYPE como tipo de argumento. A função aceita uma entrada de qualquer tipo para esse argumento. Para mais informações, consulte o parâmetro com modelo no BigQuery.

O BigQuery também oferece suporte à instrução CREATE FUNCTION IF NOT EXISTS, que trata a consulta como bem-sucedida e não realiza nenhuma ação se já houver uma função com o mesmo nome.

A instrução CREATE FUNCTION do BigQuery também oferece suporte à criação de funções TEMPORARY ou TEMP, que não têm um equivalente no Amazon Redshift.

Consulte Como chamar UDFs para ver detalhes sobre como executar uma UDF permanente do BigQuery.

Sintaxe DROP FUNCTION

A tabela a seguir mostra as diferenças na sintaxe DROP FUNCTION entre o Amazon Redshift e o BigQuery.

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

Observação: o BigQuery não exige o uso da assinatura da função para excluir a função. Além disso, não é possível remover dependências de funções no BigQuery.

O BigQuery também oferece suporte a instrução DROP FUNCTION IF EXISTS, que exclui a função somente se ela existir no conjunto de dados especificado.

O BigQuery exigirá que você especifique o project_name se a função não estiver localizada no projeto atual.

Componentes da UDF

Esta seção destaca as semelhanças e diferenças entre os componentes da UDF do Amazon Redshift e do BigQuery.

Componente Amazon Redshift BigQuery
Nome O Amazon Redshift recomenda o uso do prefixo _f para nomes de função, para evitar conflitos com nomes de função do SQL atuais ou futuras. No BigQuery, é possível usar qualquer nome personalizado de função.
Argumentos Argumentos são opcionais. É possível usar nomes e tipos de dados para argumentos de UDF em Python e somente tipos de dados para argumentos de UDF do SQL. Em UDFs do SQL, você precisa fazer referência a argumentos que usem $1, $2 e assim por diante. O Amazon Redshift também restringe o número de argumentos a 32. Os argumentos são opcionais, mas, se forem especificados, eles precisarão usar nomes e tipos de dados para UDFs em JavaScript e SQL. O número máximo de argumentos de uma UDF permanente é 256.
Tipo de dado O Amazon Redshift é compatível com um conjunto diferente de tipos de dados para UDFs do SQL e em Python.
Para uma UDF em Python, o tipo de dados também pode ser ANYELEMENT.

É necessário especificar um tipo de dados RETURN para UDFs do SQL e em Python.

Consulte Tipos de dados neste documento para conhecer os equivalentes entre os tipos de dados no Amazon Redshift e no BigQuery.		 O BigQuery oferece suporte a um conjunto diferente de tipos de dados para UDFs do SQL e em JavaScript.
Para uma UDF do SQL, o tipo de dados também pode ser ANY TYPE. Para mais informações, consulte os parâmetros com modelo no BigQuery.

O tipo de dados RETURN é opcional para UDFs do SQL.

Consulte Codificações de tipo SQL em JavaScript para mais informações sobre como os tipos de dados do BigQuery são mapeados nos tipos em JavaScript.
Definição Para UDFs do SQL e em Python, é preciso incluir a definição da função usando citação em dólares, como em um par de cifrões ($$), para indicar o início e o fim das instruções da função.

Em UDFs do SQL, o Amazon Redshift oferece suporte apenas a uma cláusula SELECT 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 em Python, é possível gravar um programa em Python usando a biblioteca padrão Python 2.7 ou importar seus módulos personalizados criando um com o comando CREATE LIBRARY .		 No BigQuery, é necessário colocar o código JavaScript entre aspas. Consulte Regras de uso de aspas para mais informações.

Nas UDFs do SQL, use qualquer expressão SQL como a definição da função. No entanto, o BigQuery não oferece suporte para referência a tabelas, visualizações ou modelos.

Em UDFs em JavaScript, é possível incluir bibliotecas de código externas diretamente, usando a seção OPTIONS . Também é possível usar a ferramenta de teste de UDF do BigQuery para testar as funções.
Idioma Use o literal LANGUAGE para especificar a linguagem como sql para UDFs do SQL ou plpythonu para UDFs em Python. Não é necessário especificar LANGUAGE para UDFs do SQL, mas é necessário especificar a linguagem como js para UDFs em JavaScript.
Estado O Amazon Redshift não é compatível com a criação de UDFs temporárias.

O Amazon Redshift oferece uma opção para definir a volatilidade de uma função usando VOLATILE, STABLE ou literais IMMUTABLE . Isso é usado para a otimização fornecida pelo otimizador de consultas.		 O BigQuery oferece suporte a UDFs permanentes e temporárias. É possível reutilizar UDFs permanentes em várias consultas, mas as UDFs temporárias só podem ser usadas uma única vez.

A volatilidade de função não é um parâmetro configurável no BigQuery. Toda a volatilidade do UDF no BigQuery é equivalente à volatilidade IMMUTABLE no Amazon Redshift.
Segurança e privilégios Para criar uma UDF, você precisa ter permissão para uso em uma linguagem para SQL ou plpythonu (Python). Por padrão, USAGE ON LANGUAGE SQL é concedido a PUBLIC, mas você precisa conceder explicitamente USAGE ON LANGUAGE PLPYTHONU a usuários ou grupos específicos.
Além disso, é preciso ser um superusuário para substituir uma UDF.		 Não é necessário conceder permissões explícitas para criar ou excluir qualquer tipo de UDF no BigQuery. Qualquer usuário com um papel de Editor de dados do BigQuery (tendo bigquery.routines.* como uma das permissões) pode criar ou excluir funções do conjunto de dados especificado.

O BigQuery também oferece suporte à criação de papéis personalizados. Isso pode ser gerenciado usando o Cloud IAM.
Limites Consulte Limites de UDF em Python. Consulte Limites de UDF.

Instruções SQL de metadados e transações

Amazon Redshift BigQuery
SELECT * FROM STL_ANALYZE WHERE name
= 'T';		 Não usado no BigQuery. Não é preciso coletar estatísticas para melhorar o desempenho da consulta. Para receber informações sobre a distribuição de dados, use funções de agregação 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 snapshot. Para ver mais detalhes, consulte Garantias de consistência.
EXPLAIN ... Não usado no BigQuery.

Recursos semelhantes são a explicação do plano de consulta, no console do BigQuery, e na geração de registros 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 Introdução ao BigQuery INFORMATION_SCHEMA.
VACUUM [table_name] Não usado no BigQuery. As tabelas em cluster do BigQuery são classificadas automaticamente.

Instruções SQL com várias instruções e linhas

O Amazon Redshift e o BigQuery tem suporte a transações (sessões) e, portanto, tem suporte a instruções separadas por ponto e vírgula que são executadas de maneira consistente em conjunto. Para mais informações, consulte Transações de várias instruções.

Instruções SQL procedurais

Instrução CREATE PROCEDURE

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

Caso contrário, use in-line com BEGIN ou em uma ú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 o valor da expressão fornecida para uma variável ou define múltiplas variáveis ao mesmo tempo, com base no resultado de várias expressões.

Gerenciadores de condição de erro

No Amazon Redshift, um erro encontrado durante a execução de um procedimento armazenado encerra o fluxo de execução, finaliza e reverte a transação. Isso ocorre porque as subtransações não são compatíveis. Em um procedimento armazenado pelo Amazon Redshift, o único handler_statement compatível é RAISE. No BigQuery, o tratamento de erros é um recurso principal do fluxo de controle principal. Ele é semelhante ao fornecido por outras linguagens 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

Como o BigQuery não é compatível com cursores ou sessões, as seguintes instruções não são usadas nele:

Se você estiver usando o cursor para obter um conjunto de resultados, um comportamento semelhante poderá ser alcançado usando as tabelas temporárias do BigQuery.

Instruções SQL dinâmicas

O recurso de criação de script no BigQuery é compatível com instruções SQL dinâmicas, como as mostradas na tabela a seguir.

Amazon Redshift BigQuery
EXECUTE EXECUTE IMMEDIATE

Instruções de fluxo de controle

Amazon Redshift BigQuery
IF..THEN..ELSIF..THEN..ELSE..END IF IF condition
THEN stmts
ELSE stmts
END IF
name CURSOR [ ( arguments ) ] FOR query Cursores nem sessões não são usados 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 da transação

O Amazon Redshift e o BigQuery são atômicos, ou seja, compatíveis com ACID em várias linhas por mutação.

Transações

O Amazon Redshift é compatível por padrão com o isolamento serializável para transações. O Amazon Redshift permite especificar qualquer um dos quatro níveis de isolamento da transação padrão do SQL, mas processa todos os níveis de isolamento como serializáveis.

O BigQuery também tem suporte a transações. O BigQuery ajuda a garantir o controle de simultaneidade otimista (primeiro a confirmar tem prioridade) com o isolamento de snapshot, em que uma consulta lê os últimos dados confirmados antes do início da consulta. Essa abordagem garante o mesmo nível de consistência por linha, por mutação e em todas as linhas da mesma instrução DML, evitando impasses. No caso de várias atualizações de DML na mesma tabela, o BigQuery alterna para controle de simultaneidade pessimista. Os jobs de carregamento podem ser executados de forma totalmente independente e anexados às tabelas.

Reverter

Se o Amazon Redshift encontrar algum erro ao executar um procedimento armazenado, ele reverterá todas as alterações feitas em uma transação. Além disso, é possível usar a instrução de controle de transação ROLLBACK em um procedimento armazenado para descartar todas as alterações.

No BigQuery, é possível usar a instrução ROLLBACK TRANSACTION.

Limites de bancos de dados

Sempre verifique a documentação pública do BigQuery para ver as cotas e os limites mais recentes. Muitas cotas para usuários de grandes volumes podem ser elevadas entrando em contato com a equipe de suporte do Cloud. Veja na tabela a seguir uma comparação entre os limites de banco de dados do Amazon Redshift e do BigQuery.

Limite Amazon Redshift BigQuery
Tabelas em cada banco de dados para tipos de nós de cluster grandes e extragrandes 9.900 Irrestrito
Tabelas em cada banco de dados para tipos de nós de cluster 8xlarge 20.000 Irrestrito
Bancos de dados definidos pelo usuário que podem ser criados para cada cluster 60 Irrestrito
Tamanho máximo da linha 4 MB 100 MB