Guida alla traduzione SQL di Amazon Redshift

Questo documento descrive le somiglianze e le differenze nella sintassi SQL tra Amazon Redshift e BigQuery per aiutarti a pianificare la migrazione. Utilizza le funzionalità di traduzione SQL batch in eseguire la migrazione collettiva degli script SQL traduzione SQL interattiva per tradurre query ad hoc.

Il pubblico di destinazione di questa guida è costituito da architetti aziendali, amministratori di database, sviluppatori di applicazioni e specialisti della sicurezza IT. Si assume che tu abbia dimestichezza con Amazon Redshift.

Tipi di dati

Questa sezione mostra gli equivalenti tra i tipi di dati in Amazon Redshift e in BigQuery.

Amazon Redshift BigQuery Note
Tipo di dati Alias Tipo di dati
SMALLINT INT2 INT64 Il valore SMALLINT di Amazon Redshift è di 2 byte, mentre il valore di BigQuery INT64 è di 8 byte.
INTEGER

INT, INT4

 INT64 INTEGER di Amazon Redshift è di 4 byte, mentre INT64 di BigQuery è di 8 byte.
BIGINT INT8 INT64 Sia BIGINT di Amazon Redshift sia INT64 di BigQuery sono di 8 byte.
DECIMAL NUMERIC NUMERIC
REAL FLOAT4 FLOAT64 Il valore REAL di Amazon Redshift è di 4 byte, mentre il valore di BigQuery FLOAT64 è di 8 byte.
DOUBLE PRECISION

FLOAT8, FLOAT

 FLOAT64
BOOLEAN BOOL BOOL BOOLEAN di Amazon Redshift può utilizzare TRUE, t, true, y, yes e 1 come valori letterali validi per true. di BigQuery Il tipo di dati BOOL non fa distinzione tra maiuscole e minuscole TRUE.
CHAR

CHARACTER, NCHAR, BPCHAR

STRING
VARCHAR

CHARACTER VARYING, NVARCHAR, TEXT

STRING
DATE DATE
TIMESTAMP TIMESTAMP WITHOUT TIME ZONE DATETIME
TIMESTAMPTZ

TIMESTAMP WITH TIME ZONE

TIMESTAMP Nota: in BigQuery vengono utilizzati i fusi orari durante l'analisi timestamp o la formattazione di timestamp per la visualizzazione. Un file con formato stringa il timestamp potrebbe includere un fuso orario, ma quando BigQuery analizza memorizza il timestamp nell'ora UTC equivalente. Quando il fuso orario non è specificato esplicitamente, il fuso orario predefinito, UTC, è in uso. I nomi dei fusi orari o l'offset rispetto a UTC utilizzando (-|+)HH:MM sono supportati, ma le abbreviazioni dei fusi orari come PDT non sono supportate.
GEOMETRY GEOGRAPHY Supporto per le query sui dati geospaziali.

BigQuery dispone anche dei seguenti tipi di dati che non hanno un diretto corrispondente in Amazon Redshift:

Tipi di conversione implicita

Durante la migrazione a BigQuery, devi convertire la maggior parte delle conversioni implicite di Amazon Redshift in conversioni esplicite di BigQuery, ad eccezione dei seguenti tipi di dati, che BigQuery converte implicitamente.

BigQuery esegue conversioni implicite per i seguenti tipi di dati:

Dal tipo BigQuery Come digitare BigQuery

INT64

FLOAT64

INT64

NUMERIC

NUMERIC

FLOAT64

BigQuery esegue anche conversioni implicite per i seguenti valori letterali:

Dal tipo BigQuery Al tipo BigQuery
STRING letterale
(ad es. "2008-12-25")

DATE

STRING letterale
(ad es. "2008-12-25 15:30:00")

TIMESTAMP

STRING letterale
(ad es. "2008-12-25T07:30:00")

DATETIME

STRING letterale
(ad es. "15:30:00")

TIME

Tipi di conversione espliciti

Puoi convertire i tipi di dati di Amazon Redshift che BigQuery non converte implicitamente utilizzando lo strumento Funzione CAST(expression AS type) o uno qualsiasi dei DATE e TIMESTAMP le funzioni di conversione.

Durante la migrazione delle query, modifica qualsiasi occorrenza di Amazon Redshift CONVERT(type, expression) (o la sintassi ::) a BigQuery nella funzione CAST(expression AS type) , come mostrato nella tabella nella sezione Funzioni di formattazione del tipo di dati.

Sintassi delle query

Questa sezione illustra le differenze di sintassi delle query tra Amazon Redshift e in BigQuery.

SELECT dichiarazione

La maggior parte delle istruzioni SELECT di Amazon Redshift è compatibile con BigQuery. La tabella seguente contiene un elenco differenze minime.

Amazon Redshift BigQuery

SELECT TOP number expression
FROM table

SELECT expression
FROM table
ORDER BY expression DESC
LIMIT number

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

Nota: Redshift supporta la creazione e fare riferimento a un alias nello stesso SELECT l'Informativa.

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

BigQuery supporta anche le seguenti espressioni nelle istruzioni SELECT, che non hanno un equivalente Amazon Redshift:

Clausola FROM

Una clausola FROM in una query elenca i riferimenti alle tabelle da cui vengono selezionati i dati. In Amazon Redshift, i possibili riferimenti a tabelle includono tabelle, visualizzazioni e sottoquery. Tutti i riferimenti alle tabelle sono supportati in BigQuery.

È possibile fare riferimento alle tabelle BigQuery nel FROM utilizzando quanto segue:

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

BigQuery supporta anche altri riferimenti alle tabelle:

Tipi di JOIN

Amazon Redshift e BigQuery supportano i seguenti tipi di join:

La tabella seguente contiene un elenco di differenze minori.

Amazon Redshift BigQuery

SELECT col
FROM table1
NATURAL INNER JOIN
table2

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


Nota: in BigQuery, le clausole JOIN richiedono una condizione JOIN, a meno che la clausola non sia CROSS JOIN o una delle tabelle unite non sia un campo all'interno di un tipo di dato o di un array.

Clausola WITH

Una clausola WITH di BigQuery contiene una o più sottoquery denominate che vengono eseguite quando un'istruzione SELECT successiva fa riferimento a queste. Le clausole WITH di Amazon Redshift si comportano come quelle di BigQuery, con l'eccezione che puoi valutare la clausola una volta e riutilizzare i relativi risultati.

Operatori Set

Esistono alcune piccole differenze tra Operatori dei set Amazon Redshift e Set BigQuery operatori. Tuttavia, tutte le operazioni sugli insiemi possibili in Amazon Redshift sono replicabili in BigQuery.

Amazon Redshift BigQuery

SELECT * FROM table1
UNION
SELECT * FROM table2

SELECT * FROM table1
UNION DISTINCT
SELECT * FROM table2

Nota: sia BigQuery che Amazon Redshift supportano l'operatore UNION ALL.

SELECT * FROM table1
INTERSECT
SELECT * FROM table2

SELECT * FROM table1
INTERSECT DISTINCT
SELECT * FROM table2

SELECT * FROM table1
EXCEPT
SELECT * FROM table2

SELECT * FROM table1
EXCEPT DISTINCT
SELECT * FROM table2

SELECT * FROM table1
MINUS
SELECT * FROM table2

SELECT * FROM table1
EXCEPT DISTINCT
SELECT * FROM table2

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

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


Nota: BigQuery richiede le parentesi per separare set diversi operazioni aziendali. Se lo stesso operatore di insieme viene ripetuto, le parentesi non sono necessarie.

Clausola ORDER BY

Esistono alcune differenze minori tra le clausole di Amazon Redshift ORDER BY e le clausole di BigQuery ORDER BY.

Amazon Redshift BigQuery
In Amazon Redshift, i valori NULL sono classificati per ultimi per impostazione predefinita (ordine crescente). In BigQuery, i valori NULL vengono classificati per primi per impostazione predefinita (ordine crescente).

SELECT *
FROM table
ORDER BY expression
LIMIT ALL

SELECT *
FROM table
ORDER BY expression



Nota: BigQuery non utilizza la sintassi LIMIT ALL, ma ORDER BY ordina tutte le righe per impostazione predefinita, con lo stesso comportamento della clausola LIMIT ALL di Amazon Redshift. Ti consigliamo vivamente di includere una clausola LIMIT con ogni clausola ORDER BY. Ordinare tutte le righe dei risultati inutilmente peggiora le prestazioni di esecuzione delle query.

SELECT *
FROM table
ORDER BY expression
OFFSET 10

SELECT *
FROM table
ORDER BY expression
LIMIT count OFFSET 10



Nota: in BigQuery, OFFSET deve essere utilizzato insieme a LIMIT conteggio. Assicurati di impostare il valore count INT64 sul numero minimo di righe ordinate necessarie. L'ordinamento di tutte le righe dei risultati
comporta un degrado non necessario delle prestazioni di esecuzione delle query.

Condizioni

La tabella seguente mostra le condizioni Amazon Redshift, o predicati, che sono specifici di Amazon Redshift e devono essere convertiti Equivalente BigQuery.

Amazon Redshift BigQuery

a = ANY (subquery)

a = SOME (subquery)

a IN subquery

a <> ALL (subquery)

a != ALL (subquery)

a NOT IN subquery

a IS UNKNOWN

expression ILIKE pattern

a IS NULL

LOWER(expression) LIKE LOWER(pattern)

expression LIKE pattern ESCAPE 'escape_char'

expression LIKE pattern


Nota: BigQuery non supporta i caratteri di escape personalizzati. Devi utilizzare due barre rovesciate \\ come caratteri di escape per BigQuery.

expression [NOT] SIMILAR TO pattern

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


Nota: se NOT è specificato, aggrega quanto riportato sopra Espressione IF in un'espressione NOT come mostrato sotto:

NOT(
IF(
LENGTH(...
)

expression [!] ~ pattern

[NOT] REGEXP_CONTAINS(
expression,
regex
)

Funzioni

Le sezioni seguenti elencano le funzioni di Amazon Redshift e i relativi equivalenti di BigQuery.

Funzioni di aggregazione

La tabella seguente mostra le mappature tra i dati aggregati di Amazon Redshift e i dati aggregati funzioni analitiche e di aggregazione approssimate con gli equivalenti 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() e

Nota: non copre i casi d'uso relativi all'aggregazione.
STDDEV([DISTINCT] expression) STDDEV([DISTINCT] expression)
STDDEV_SAMP([DISTINCT] expression) STDDEV_SAMP([DISTINCT] expression)
STDDEV_POP([DISTINCT] expression) STDDEV_POP([DISTINCT] expression)
SUM([DISTINCT] expression) SUM([DISTINCT] expression)
VARIANCE([DISTINCT] expression) VARIANCE([DISTINCT] expression)
VAR_SAMP([DISTINCT] expression) VAR_SAMP([DISTINCT] expression)
VAR_POP([DISTINCT] expression) VAR_POP([DISTINCT] expression)

BigQuery offre anche le seguenti funzioni di aggregazione, analisi aggregata e aggregazione approssimativa, che non hanno un analogo diretto in Amazon Redshift:

Funzioni di aggregazione a livello di bit

La tabella seguente mostra le mappature tra l'aggregazione bit a bit di Amazon Redshift comune con i rispettivi equivalenti BigQuery.

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

BigQuery offre anche le seguenti opzioni aggregata a bit , che non ha un analogo diretto in Amazon Redshift:

Funzioni finestra

La tabella seguente mostra le mappature tra le funzioni finestra di Amazon Redshift comuni con gli equivalenti BigQuery. Le funzioni finestra in BigQuery includono funzioni di aggregazione analitica, funzioni di aggregazione, funzioni di navigazione e funzioni di numerazione.


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

Espressioni condizionali

La tabella seguente mostra le mappature tra le comuni condizionali di Amazon Redshift con i rispettivi equivalenti BigQuery.

Amazon Redshift BigQuery
CASEexpression
WHEN value THEN result
[WHEN...]
[ELSE else_result]
END		 CASE expression
WHEN value THEN result
[WHEN...]
[ELSE else_result]
END
COALESCE(expression1[, ...]) COALESCE(expression1[, ...])
DECODE(
expression,
search1, result1
[, search2, result2...]
[, default]
) 		CASE expression
WHEN value1 THEN result1
[WHEN value2 THEN result2]
[ELSE default]
END
GREATEST(value [, ...]) GREATEST(value [, ...])
LEAST(value [, ...]) LEAST(value [, ...])
NVL(expression1[, ...]) COALESCE(expression1[, ...])
NVL2(
expression,
not_null_return_value,
null_return_value
)		 IF(
expression IS NULL,
null_return_value,
not_null_return_value
)
NULLIF(expression1, expression2) NULLIF(expression1, expression2)

BigQuery offre inoltre le seguenti espressioni condizionali, che non hanno un analogico diretto in Amazon Redshift:

Funzioni di data e ora

La tabella seguente mostra le mappature tra le funzioni di data e ora comuni di Amazon Redshift e i relativi equivalenti di BigQuery. Funzioni di dati e ora di BigQuery includi funzioni di data, dataora funzioni, funzioni temporali, e funzioni timestamp.

Tieni presente che le funzioni che sembrano identiche in Amazon Redshift e BigQuery potrebbero restituire tipi di dati diversi.

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: i fusi orari vengono utilizzati durante l'analisi dei timestamp o la loro formattazione per la visualizzazione. Un file con formato stringa il timestamp potrebbe includere un fuso orario, ma quando BigQuery analizza memorizza il timestamp nell'ora UTC equivalente. Quando il fuso orario non è specificato esplicitamente, il fuso orario predefinito, UTC, è in uso. I nomi dei fusi orari o l'offset rispetto al fuso orario UTC (-HH:MM) sono supportato, ma le abbreviazioni dei fusi orari (ad esempio PDT) non sono supportate supportati.
CONVERT_TIMEZONE(
[source_timezone],
target_timezone,
timestamp
)		 PARSE_TIMESTAMP(
"%c%z",
FORMAT_TIMESTAMP(
"%c%z",
timestamp,
target_timezone
)
)

Nota: source_timezone è UTC in BigQuery.
CURRENT_DATE

Nota: restituisce la data di inizio della transazione corrente nell'account fuso orario della sessione (UTC per impostazione predefinita). 		CURRENT_DATE() e

Nota: restituisce la data di inizio dell'istruzione corrente nel fuso orario UTC zona di destinazione.
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
) 		Per gli intervalli in Redshift, un anno è composto da 360 giorni. In BigQuery, puoi utilizzare le seguenti opzioni per analizzare un intervallo Redshift e in secondi.

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

Per confrontare i valori letterali degli intervalli, esegui:

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: restituisce il timestamp di inizio della transazione corrente nel fuso orario della sessione corrente (UTC per impostazione predefinita). 		CURRENT_TIMESTAMP()

Nota: restituisce il timestamp di inizio dell'istruzione corrente nel fuso orario UTC.
TIMEOFDAY() FORMAT_TIMESTAMP(
"%a %b %d %H:%M:%E6S %E4Y %Z",
CURRENT_TIMESTAMP())
TIMESTAMP_CMP(
timestamp1,
timestamp2
)		 CASE
WHEN timestamp1 = timestamp2
THEN 0
WHEN timestamp1 > timestamp2
THEN 1
ELSE -1
END
TIMESTAMP_CMP_DATE(
timestamp,
date
) 		CASE
WHEN
EXTRACT(
DATE FROM timestamp
) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamp) > date
THEN 1
ELSE -1
END
TIMESTAMP_CMP_TIMESTAMPTZ(
timestamp,
timestamptz
)

Nota: Redshift confronta i timestamp nel fuso orario definito dalla sessione utente. Il fuso orario predefinito della sessione utente è UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Nota: BigQuery confronta i timestamp nel fuso orario UTC.
TIMESTAMPTZ_CMP(
timestamptz1,
timestamptz2
)

Nota: Redshift confronta i timestamp nel fuso orario definito dalla sessione utente. Il fuso orario predefinito della sessione utente è UTC. 		CASE
WHEN timestamptz1 = timestamptz2
THEN 0
WHEN timestamptz1 > timestamptz2
THEN 1
ELSE -1
END

Nota: BigQuery confronta i timestamp nel fuso orario UTC.
TIMESTAMPTZ_CMP_DATE(
timestamptz,
date
)

Nota: Redshift confronta i timestamp nel fuso orario definito dalla sessione utente. Il fuso orario predefinito della sessione utente è UTC. 		CASE
WHEN
EXTRACT(
DATE FROM timestamptz) = date
THEN 0
WHEN
EXTRACT(
DATE FROM timestamptz) > date
THEN 1
ELSE -1
END

Nota: BigQuery confronta i timestamp nel fuso orario UTC.
TIMESTAMPTZ_CMP_TIMESTAMP(
timestamptz,
Timestamp
)

Nota: Redshift confronta i timestamp relativi al tempo definito dalla sessione utente zona di destinazione. Il fuso orario predefinito della sessione utente è UTC. 		CASE
WHEN timestamp = timestamptz
THEN 0
WHEN timestamp > timestamptz
THEN 1
ELSE -1
END

Nota: BigQuery confronta i timestamp nel fuso orario UTC.
TIMEZONE(
timezone,
Timestamptz_or_timestamp
) 		PARSE_TIMESTAMP(
"%c%z", FORMAT_TIMESTAMP(
"%c%z",
timestamptz_or_timestamp,
timezone
)
)

Nota: i fusi orari vengono utilizzati durante l'analisi dei timestamp o la loro formattazione per la visualizzazione. Un file con formato stringa il timestamp potrebbe includere un fuso orario, ma quando BigQuery analizza memorizza il timestamp nell'ora UTC equivalente. Quando un fuso orario non è specificato esplicitamente, viene utilizzato il fuso orario predefinito UTC. I nomi dei fusi orari o l'offset rispetto al fuso orario UTC (-HH:MM) sono supportato, ma le abbreviazioni del fuso orario (ad esempio PDT) non sono supportate supportati.
TO_TIMESTAMP(timestamp, format) PARSE_TIMESTAMP(
format,
FORMAT_TIMESTAMP(
format,
timestamp
)
)

Nota: BigQuery segue un insieme diverso di elementi di formato. I fusi orari vengono utilizzati per analizzare i timestamp o per formattarli per la visualizzazione. Un timestamp in formato stringa potrebbe includere un fuso orario, ma quando BigQuery analizza la stringa, archivia il timestamp nell'ora UTC equivalente. Quando un fuso orario non è specificato esplicitamente, viene utilizzato il fuso orario predefinito UTC. I nomi dei fusi orari o l'offset rispetto al fuso orario UTC (-HH:MM) sono supportato nella stringa del formato, ma le abbreviazioni del fuso orario (come PDT) non sono supportate.
TRUNC(timestamp) CAST(timestamp AS DATE)

BigQuery offre anche le seguenti funzioni di data e ora, che non hanno un analogo diretto in Amazon Redshift:

Operatori matematici

La tabella seguente mostra le mappature tra gli operatori matematici comuni di Amazon Redshift e i relativi equivalenti di BigQuery.

Amazon Redshift BigQuery

X + Y

X + Y

X - Y

X - Y

X * Y

X * Y

X / Y


Nota: se l'operatore
esegue la divisione tra interi (in altre parole, se X e Y sono entrambi interi), viene restituito un intero. Se l'operatore esegue una divisione non intera, viene restituito un valore non intero.		 Se la divisione del numero intero:
CAST(FLOOR(X / Y) AS INT64)

Se non è una divisione intera:

CAST(X / Y AS INT64)


Nota: la divisione in BigQuery restituisce un valore non intero.
Per evitare errori da un'operazione di divisione (errore di divisione per zero), usa SAFE_DIVIDE(X, Y) o IEEE_DIVIDE(X, Y).

X % Y

MOD(X, Y)


Nota: per evitare errori da un'operazione di divisione (divisione per zero) ), utilizza SAFE.MOD(X, Y). SAFE.MOD(X, 0) risultati in 0.

X ^ Y

POW(X, Y)

POWER(X, Y)


Nota: a differenza di Amazon Redshift, l'operatore ^ in BigQuery esegue bitwise xor.

| / X

SQRT(X)


Nota: per evitare errori da un'operazione radice quadrata (valore negativo ), utilizza SAFE.SQRT(X). Input negativo con SAFE.SQRT(X) risultati in NULL.

|| / X

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


Nota: POWER(X, Y) di BigQuery restituisce un errore se X è un valore finito inferiore a 0 e Y è un numero non intero.

@ X

ABS(X)

X << Y

X << Y


Nota: questo operatore restituisce 0 o una sequenza di byte di b'\x00' se le il secondo operando Y è maggiore o uguale alla lunghezza in bit della primo operando X (ad esempio, 64 se X è di tipo INT64). Questo l'operatore genera un errore se Y è negativo.

X >> Y

X >> Y


Nota: sposta il primo operando X verso destra. Questo operatore non l'estensione bit di segno con un tipo firmato (riempie i bit vuoti sulla lasciato con 0). Questo operatore restituisce 0 o una sequenza di byte di
b'\x00' se il secondo operando Y è maggiore o uguale alla lunghezza in bit del primo operando X (ad esempio 64 se X è di tipo INT64). Questo operatore genera un errore se Y è negativo.

X & Y

X & Y

X | Y

X | Y

~X

~X

BigQuery offre anche il seguente operatore matematico, che non ha un analogo diretto in Amazon Redshift:

  • X ^ Y (Xor di scambio di bit)

Funzioni matematiche

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

Funzioni di stringa

Amazon Redshift BigQuery
string1 || string2 CONCAT(string1, string2)
BPCHARCMP(string1, string2) CASE
WHEN string1 = string2 THEN 0
WHEN string1 > string2 THEN 1
ELSE -1
END
BTRIM(string [, matching_string]) TRIM(string [, matching_string])
BTTEXT_PATTERN_CMP(string1, string2) CASE
WHEN string1 = string2 THEN 0
WHEN string1 > string2 THEN 1
ELSE -1
END
CHAR_LENGTH(expression) CHAR_LENGTH(expression)
CHARACTER_LENGTH(expression) CHARACTER_LENGTH(expression)
CHARINDEX(substring, string) STRPOS(string, substring)
CHR(number) CODE_POINTS_TO_STRING([number])
CONCAT(string1, string2) CONCAT(string1, string2)

Nota: CONCAT(...) di BigQuery supporta la concatenazione di un numero qualsiasi di stringhe.
CRC32 Funzione personalizzata definita dall'utente
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 è specificato:

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

Nota: BigQuery fornisce il supporto per le espressioni regolari utilizzando la libreria re2; vedi che documentazione per la sintassi delle espressioni regolari.
REGEXP_INSTR(
source_string,
pattern
[,position
[,occurrence]] )
IFNULL( STRPOS(
source_string, REGEXP_EXTRACT(
source_string,
pattern)
),0)
Se source_string è specificato:

REGEXP_REPLACE(
source_string,

pattern,
replace_string
)

Se position è specificato:

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 è specificato:

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

Nota: BigQuery fornisce l'espressione regolare
assistenza utilizzando il re2 biblioteca; scopri che
documentazione per la sua espressione regolare
a riga di comando.
REGEXP_REPLACE( source_string,
pattern
[, replace_string [, position]]
) 		REGEXP_REPLACE(
source_string,
pattern,
""
)

Se è specificato source_string:

REGEXP_REPLACE(
source_string,

pattern, replace_string
)

Se è specificato position:

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

Se è specificato position:

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

)

Se è specificato occurrence:

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


pattern
)[SAFE_ORDINAL(occurrence)]

Nota: BigQuery fornisce il supporto delle espressioni regolari utilizzando la libreria re2. Consulta la documentazione per la sintassi delle espressioni regolari.
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 ) 		Può essere implementata utilizzando le funzioni definite dall'utente:

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)

Funzioni di formattazione dei tipi di dati

Amazon Redshift BigQuery
CAST(expression AS type) CAST(expression AS type)
expression :: type CAST(expression AS type)
CONVERT(type, expression) CAST(expression AS type)
TO_CHAR(
timestamp_expression, format
)		 FORMAT_TIMESTAMP(
format,
timestamp_expression
)

Nota: BigQuery e Amazon Redshift differiscono nel modo in cui stringa per timestamp_expression.
TO_CHAR(
numeric_expression,
format
)		 FORMAT(
format,
numeric_expression
)

Nota: BigQuery e Amazon Redshift differiscono per la modalità di specifica di una stringa di formato per timestamp_expression.
TO_DATE(date_string, format) PARSE_DATE(date_string, format)

Nota: BigQuery e Amazon Redshift differiscono per la modalità di specifica di una stringa di formato per date_string.
TO_NUMBER(string, format) CAST(
FORMAT(
format,
numeric_expression
) TO INT64
)

Nota: BigQuery e Amazon Redshift differiscono per la modalità di specifica di una stringa di formato numerico.

BigQuery supporta anche SAFE_CAST(expression AS typename), che restituisce NULL se BigQuery non è in grado di eseguire una trasmissione. della un esempio, SAFE_CAST("apple" AS INT64) restituisce NULL.

Sintassi DML

Questa sezione illustra le differenze nella sintassi del linguaggio di gestione dei dati tra Amazon Redshift e BigQuery.

Istruzione INSERT

Amazon Redshift offre una parola chiave DEFAULT configurabile per le colonne. In BigQuery, il valore DEFAULT per le colonne con valori null è NULL e DEFAULT non è supportato per le colonne obbligatorie. La maggior parte delle istruzione INSERT di Amazon Redshift è compatibile con BigQuery. La tabella seguente mostra le eccezioni.

Amazon Redshift BigQuery
INSERT INTO table (column1 [, ...])
DEFAULT VALUES		 INSERT [INTO] table (column1 [, ...])
VALUES (DEFAULT [, ...])
INSERT INTO table (column1, [,...]) VALUES (
SELECT ...
FROM ...
)		 INSERT [INTO] table (column1, [,...])
SELECT ...
FROM ...

BigQuery supporta anche l'inserimento di valori utilizzando una sottoquery (in cui uno dei valori viene calcolato utilizzando una sottoquery), che non è supportato in Amazon Redshift. Ad esempio:

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

COPY dichiarazione

Il comando COPY di Amazon Redshift carica i dati in una tabella da file di dati o da una tabella Amazon DynamoDB. BigQuery non utilizza il comando SQL COPY per caricare i dati, ma puoi utilizzare uno qualsiasi dei vari strumenti e opzioni non SQL caricare dati in tabelle BigQuery. Puoi anche utilizzare gli sink delle pipeline di dati forniti in Apache Spark o Apache Beam per scrivere dati in BigQuery.

UPDATE dichiarazione

La maggior parte delle istruzioni UPDATE di Amazon Redshift è compatibile con BigQuery. La tabella seguente mostra le eccezioni.

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

Nota: tutte le istruzioni UPDATE in BigQuery richiedono una parola chiave WHERE, followed by a condition.
UPDATE table
SET column = DEFAULT [,...] [FROM ...]
[WHERE ...]		 UPDATE table
SET column = NULL [, ...]
[FROM ...]
WHERE ...

Nota: il comando UPDATE di BigQuery non supporta i valori DEFAULT.

Se l'istruzione UPDATE di Amazon Redshift non include una clausola WHERE, l'istruzione UPDATE di BigQuery deve essere condizionata WHERE TRUE.

DELETE e TRUNCATE estratti conto

Le istruzioni DELETE e TRUNCATE sono entrambi modi per rimuovere righe da una tabella senza influire sullo schema o sugli indici della tabella.

In Amazon Redshift, l'istruzione TRUNCATE è consigliata rispetto a un'istruzione DELETE non qualificata perché è più rapida e non richiede operazioni VACUUM e ANALYZE successive. Tuttavia, puoi utilizzare le istruzioni DELETE per ottenere lo stesso effetto.

In BigQuery, l'istruzione DELETE deve avere una clausola WHERE. Per maggiori informazioni informazioni su DELETE in BigQuery, consulta BigQuery DELETE esempi nella documentazione di DML.

Amazon Redshift BigQuery
DELETE [FROM] table_name

TRUNCATE [TABLE] table_name		 DELETE FROM table_name
WHERE TRUE

Le istruzioni DELETE di BigQuery richiedono una clausola 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 )

In Amazon Redshift, USING consente tabelle aggiuntive a cui si fa riferimento nel WHERE. Questo risultato può essere ottenuto in BigQuery utilizzando una sottoquery nella clausola WHERE.

MERGE dichiarazione

L'istruzione MERGE può combinare INSERT, UPDATE, e DELETE in un un'unica istruzione upsert ed eseguire le operazioni a livello atomico. MERGE deve corrispondere al massimo a una riga di origine per ogni riga target.

Amazon Redshift non supporta un solo comando MERGE. Tuttavia, un operazione di unione che può essere eseguita in Amazon Redshift Operazioni di INSERT, UPDATE e DELETE in una transazione.

Operazione di unione sostituendo righe esistenti

In Amazon Redshift, è possibile eseguire un'sovriscrivizione di tutte le colonne della tabella di destinazione utilizzando un'istruzione DELETE e poi un'istruzione INSERT. DELETE rimuove le righe che devono essere aggiornate, mentre l'istruzione INSERT inserisce le righe aggiornate. Le tabelle BigQuery sono limitate a 1000 istruzioni DML al giorno, quindi devi consolidare INSERT, UPDATE e DELETE in una singola istruzione MERGE, come illustrato nella seguente tabella.

Amazon Redshift BigQuery
Consulta Eseguire un'operazione di associazione sostituendo le righe esistenti.

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: tutte le colonne devono essere elencate se vuoi aggiornarle tutte.
Consulta Eseguire un'operazione di associazione specificando un elenco di colonne.

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

Sintassi DDL

Questa sezione illustra le differenze nella sintassi del linguaggio di definizione dei dati tra Amazon Redshift e BigQuery.

Istruzione SELECT INTO

In Amazon Redshift, l'istruzione SELECT INTO può essere utilizzata per inserire i risultati di una query in una nuova tabella, combinando la creazione e l'inserimento della tabella.

Amazon Redshift BigQuery
SELECT expression, ... INTO table
FROM ... 		INSERT table
SELECT expression, ...
FROM ...
WITH subquery_table AS ( SELECT ...
)
SELECT expression, ... INTO table
FROM subquery_table
... 		INSERT table
WITH subquery_table AS (
SELECT ...
)
SELECT expression, ...
FROM subquery_table
...
SELECT expression
INTO TEMP table
FROM ...

SELECT expression
INTO TEMPORARY table
FROM ... 		BigQuery offre diversi modi per emulare le tabelle temporanee. Per ulteriori informazioni, consulta la sezione relativa alle tabelle temporanee.

Istruzione CREATE TABLE

La maggior parte delle istruzioni di Amazon Redshift CREATE TABLE è compatibile con BigQuery, ad eccezione dei seguenti elementi di sintassi, che non vengono utilizzati in 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: i vincoli UNIQUE e PRIMARY KEY sono informativi e non sono applicata dal sistema di 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: i vincoli UNIQUE e PRIMARY KEY sono informativi e non vengono applicati dal sistema Amazon Redshift. 		CREATE TABLE table_name
(
col1 data_type1[,...]
)
PARTITION BY column_name
CLUSTER BY column_name [, ...]

Nota: BigQuery non utilizza le tabelle UNIQUE, PRIMARY KEY o FOREIGN KEY i vincoli. Per ottenere un'ottimizzazione simile offerta da questi vincoli durante l'esecuzione delle query, partizionare e raggruppare le tabelle BigQuery. CLUSTER BY supporta fino a 4 colonne.
CREATE TABLE table_name
LIKE original_table_name 		Consulta questo esempio per scoprire come utilizzare le tabelle INFORMATION_SCHEMA per copiare i nomi delle colonne, i tipi di dati e i vincoli NOT NULL in una nuova tabella.
CREATE TABLE table_name
(
col1 data_type1
)
BACKUP NO

Nota: in Amazon Redshift, l'impostazione BACKUP NO è specificata per risparmiare tempo di elaborazione e ridurre di archiviazione.		 L'opzione della tabella BACKUP NO non è utilizzata o necessaria perché BigQuery conserva automaticamente per 7 giorni le versioni storiche di tutti le tabelle senza alcun effetto sul tempo di elaborazione o sull'archiviazione fatturata.
CREATE TABLE table_name
(
col1 data_type1
)
table_attributes
where table_attributes are:
[DISTSTYLE {AUTO|EVEN|KEY|ALL}]
[DISTKEY (column_name)]
[[COMPOUND|INTERLEAVED] SORTKEY
(column_name [, ...])] 		BigQuery supporta il clustering, che consente di archiviare le chiavi in ordine.
CREATE TABLE table_name
AS SELECT ... 		CREATE TABLE table_name
AS SELECT ...
CREATE TABLE IF NOT EXISTS table_name ... CREATE TABLE IF NOT EXISTS
table_name
...

BigQuery supporta anche l'istruzione DDL CREATE OR REPLACE TABLE, che sovrascrive una tabella se esiste già.

L'istruzione CREATE TABLE di BigQuery supporta anche le seguenti clausole, che non hanno un equivalente in Amazon Redshift:

Per saperne di più su CREATE TABLE in BigQuery, consulta BigQuery CREATE TABLE esempi nella documentazione di DML.

Tabelle temporanee

Amazon Redshift supporta le tabelle temporanee, che sono visibili solo all'interno della sessione corrente. Esistono diversi modi per emulare tabelle temporanee in BigQuery:

  • TTL del set di dati: crea un set di dati di breve durata (ad ad esempio un'ora) in modo che tutte le tabelle create nel set di dati sono temporanei poiché non si mantengono più a lungo rispetto a quelli del set di dati durata. Puoi anteporre a tutti i nomi delle tabelle in questo set di dati il prefisso temp per indicare chiaramente che le tabelle sono temporanee.

  • TTL tabella: crea una tabella con un TTL breve specifico per la tabella utilizzando istruzioni DDL simili alla seguente:

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

CREATE VIEW dichiarazione

La tabella seguente mostra gli equivalenti tra Amazon Redshift e BigQuery per il 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 ...
Non supportati. CREATE VIEW IF NOT EXISTS c view_name
OPTIONS(view_option_list)
AS SELECT …

Crea una nuova vista solo se non esiste nel set di dati specificato.
CREATE VIEW view_name
AS SELECT ...
WITH NO SCHEMA BINDING

In Amazon Redshift è necessaria una vista con il binding tardivo per fare riferimento a una tabella esterna.		 In BigQuery, per creare una visualizzazione, tutti gli oggetti a cui viene fatto riferimento devono già essere esistenti.

BigQuery ti consente di eseguire query su origini dati esterne.

Funzioni definite dall'utente

Una funzione definita dall'utente consente di creare funzioni per operazioni personalizzate. Queste funzioni accettano colonne di input, eseguire azioni e restituire il risultato di queste azioni come valore.

Sia Amazon Redshift che BigQuery supportano le funzioni definite dall'utente che utilizzano espressioni SQL. Inoltre, Amazon Redshift, puoi creare UDF basata su Python, e in BigQuery puoi creare UDF basata su JavaScript.

Consulta il repository GitHub delle utilità Google Cloud BigQuery per una libreria di funzioni definite dall'utente BigQuery comuni.

Sintassi di CREATE FUNCTION

La seguente tabella illustra le differenze nella sintassi di creazione delle funzioni UDF SQL tra Amazon Redshift e 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: in una UDF SQL di BigQuery, un tipo di dati restituiti è facoltativo. BigQuery deduce il tipo di risultato della funzione dal Corpo della funzione SQL quando una query chiama la funzione.
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
{ VOLATILE | STABLE | IMMUTABLE } AS $$
sql_function_definition
$$ LANGUAGE sql 		CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
AS sql_function_definition

Nota: la volatilità della funzione non è un parametro configurabile in in BigQuery. Tutta la volatilità delle funzioni definite dall'utente di BigQuery è equivalente a quella di Amazon Redshift Volatilità di IMMUTABLE (ovvero, non esegue ricerche nel database o altrimenti userà informazioni non presenti direttamente nel suo elenco di argomenti).
CREATE [OR REPLACE] FUNCTION
function_name
([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type
IMMUTABLE
AS $$
SELECT_clause
$$ LANGUAGE sql

Nota: Amazon Redshift supporta solo una clausola SQL SELECT come funzione definizione di Kubernetes. Inoltre, la clausola SELECT non può includere nessuna delle clausole 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: BigQuery supporta qualsiasi espressione SQL come definizione delle funzioni. Tuttavia, non è supportato fare riferimento a tabelle, viste o modelli.
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: il valore letterale della lingua non deve essere specificato in una funzione definita dall'utente di GoogleSQL. BigQuery interpreta l'espressione SQL per impostazione predefinita. Inoltre, Amazon Redshift citazione in dollari ($$) is not supported in BigQuery.
CREATE [OR REPLACE] FUNCTION function_name (integer, integer) RETURNS integer IMMUTABLE AS $$ SELECT $1 + $2 $$ LANGUAGE sql CREATE [OR REPLACE] FUNCTION
function_name
(x INT64, y INT64)
RETURNS INT64
AS
SELECT x + y

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

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

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

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

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

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

DROP FUNCTION syntax

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

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

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

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

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

UDF components

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

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

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

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

The RETURN data type is optional for SQL UDFs.

See SQL type encodings in JavaScript for information on how BigQuery data types map to JavaScript data types.
Definition For both SQL and Python UDFs, you must enclose the function definition using dollar quoting, as in a pair of dollar signs ($$), per indicare l'inizio e la fine della funzione istruzioni.

Per le funzioni UDF SQL, Amazon Redshift supporta solo una SELECT clausola SQL come definizione della funzione. Inoltre, la clausola SELECT non può includere le clausole FROM, INTO, WHERE, GROUP
BY, ORDER BY e LIMIT .

Per le funzioni UDF di Python, puoi scrivere un programma Python utilizzando la libreria standard di Python 2.7 o importare i tuoi moduli personalizzati creandone uno utilizzando il comando CREATE LIBRARY .		 In BigQuery, devi racchiudere il codice JavaScript tra virgolette. Per ulteriori informazioni, consulta le regole relative alle citazioni.

Per le UDF SQL, puoi utilizzare qualsiasi espressione SQL come definizione di funzione. Tuttavia, BigQuery non supportano i riferimenti a tabelle, viste o modelli.

Per le UDF JavaScript, puoi includere librerie di codice esterne direttamente usando la sezione OPTIONS . Puoi anche utilizzare lo strumento di test delle funzioni UDF di BigQuery per testare le tue funzioni.
Lingua Devi usare il formato LANGUAGE letterale per specificare come sql per le funzioni definite dall'utente di SQL o plpythonu per le funzioni definite dall'utente in Python. Non devi specificare LANGUAGE per le funzioni SQL definite dall'utente, ma devi specificare la lingua js per le funzioni JavaScript definite dall'utente.
Stato Amazon Redshift non supporta la creazione di funzioni UDF temporanee.

Amazon Redshift offre un'opzione per definire la volatilità di una funzione utilizzando i valori letterali VOLATILE, STABLE o IMMUTABLE . Questo viene utilizzato per l'ottimizzazione dall'ottimizzatore delle query.		 BigQuery supporta le funzioni UDF sia permanenti che temporanee. Puoi riutilizzare funzioni definite dall'utente permanenti per più query, mentre è possibile usare solo funzioni definite dall'utente temporanee in una singola query.

La volatilità della funzione non è un parametro configurabile in BigQuery. Tutta la volatilità delle funzioni UDF di BigQuery è equivalente alla volatilità IMMUTABLE di Amazon Redshift.
Sicurezza e privilegi Per creare una UDF, devi disporre dell'autorizzazione per l'utilizzo nel linguaggio per SQL o plpythonu (Python). Per impostazione predefinita, USAGE ON LANGUAGE SQL è stato concesso a PUBLIC, ma devi concedere esplicitamente USAGE ON LANGUAGE PLPYTHONU a utenti o gruppi specifici.
Inoltre, devi essere un superutente per sostituire una UDF.		 In BigQuery non è necessario concedere autorizzazioni esplicite per la creazione o l'eliminazione di qualsiasi tipo di UDF. Qualsiasi utente a cui è stato assegnato il ruolo Editor dati BigQuery (con bigquery.routines.* come una delle autorizzazioni) può creare o eliminare funzioni per il set di dati specificato.

BigQuery supporta anche la creazione di ruoli personalizzati. Questo può essere gestito utilizzando Cloud IAM.
Limiti Consulta i limiti delle funzioni UDF di Python. Consulta la sezione Limiti delle funzioni definite dall'utente.

Istruzioni SQL per metadati e transazioni

Amazon Redshift BigQuery
SELECT * FROM STL_ANALYZE WHERE name
= 'T';		 Non utilizzato in BigQuery. Non è necessario raccogliere statistiche per migliorare il rendimento delle query. Per ottenere informazioni sulla distribuzione dei dati, puoi utilizzare le funzioni di aggregazione approssimativa.
ANALYZE [[ table_name[(column_name
[, ...])]]		 Non utilizzato in BigQuery.
LOCK TABLE table_name; Non utilizzato in BigQuery.
BEGIN TRANSACTION; SELECT ...
END TRANSACTION;		 BigQuery utilizza l'isolamento degli snapshot. Per maggiori dettagli, consulta la sezione Coerenza garantiti.
EXPLAIN ... Non utilizzato in BigQuery.

Funzionalità simili sono la spiegazione del piano di query nella console Google Cloud BigQuery e nel logging di controllo in Cloud Monitoring.
SELECT * FROM SVV_TABLE_INFO WHERE
table = 'T';		 SELECT * EXCEPT(is_typed) FROM
mydataset.INFORMATION_SCHEMA.TABLES;

Per ulteriori informazioni, consulta Introduzione a BigQuery INFORMATION_SCHEMA.
VACUUM [table_name] Non utilizzato in BigQuery. Le tabelle in cluster vengono ordinate automaticamente di BigQuery.

Istruzioni SQL a più istruzioni e multiriga

Sia Amazon Redshift che BigQuery supportano le transazioni (sessioni) e quindi supportano le istruzioni separate da punti e virgola che vengono eseguite in modo coerente insieme. Per ulteriori informazioni, consulta la sezione Transazioni con più istruzioni.

Istruzioni SQL procedurali

CREATE PROCEDURE dichiarazione

Amazon Redshift BigQuery
CREATE or REPLACE PROCEDURE CREATE PROCEDURE se il nome è obbligatorio.

Altrimenti, usalo in linea con BEGIN o in una singola riga con CREATE TEMP FUNCTION.
CALL CALL

Dichiarazione e assegnazione di variabili

Amazon Redshift BigQuery
DECLARE DECLARE

Dichiara una variabile del tipo specificato.
SET SET

Imposta una variabile in modo che abbia il valore dell'espressione fornita o imposta più variabili contemporaneamente in base al risultato di più espressioni.

Gestori delle condizioni di errore

In Amazon Redshift si è verificato un errore durante l'esecuzione di una stored procedure termina il flusso di esecuzione, termina la transazione ed esegue il rollback della transazione. Questi risultati si verificano perché le sottotransazioni non sono supportate. In un Procedura archiviata da Amazon Redshift, l'unica handler_statement supportata è RAISE. In BigQuery, la gestione degli errori è una funzionalità di base del flusso di controllo principale, simile a quella fornita da altri linguaggi con i blocchi 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;

Dichiarazioni e operazioni del cursore

Poiché BigQuery non supporta cursori o sessioni, le seguenti istruzioni non vengono utilizzate in BigQuery:

Se utilizzi il cursore per restituire un insieme di risultati, puoi ottenere un comportamento simile utilizzando le tabelle temporanee in BigQuery.

Istruzioni SQL dinamiche

La funzionalità di scripting in BigQuery supporta istruzioni SQL dinamiche come quelle mostrate di seguito tabella.

Amazon Redshift BigQuery
EXECUTE EXECUTE IMMEDIATE

Istruzioni di controllo del flusso

Amazon Redshift BigQuery
IF..THEN..ELSIF..THEN..ELSE..END IF IF condition
THEN stmts
ELSE stmts
END IF
name CURSOR [ ( arguments ) ] FOR query I cursori o le sessioni non vengono utilizzati in BigQuery.
[< LOOP
sql_statement_list END LOOP;
WHILE condition LOOP stmts END LOOP WHILE condition
DO stmts
END WHILE
EXIT BREAK

Garanzie di coerenza e isolamento delle transazioni

Sia Amazon Redshift che BigQuery sono atomici, ovvero compatibili con ACID per singola mutazione livello su più righe.

Transazioni

Amazon Redshift supporta per impostazione predefinita l'isolamento serializzabile per le transazioni. Amazon Redshift ti consente di specificare uno dei quattro livelli di isolamento delle transazioni standard SQL, ma elabora tutti livelli di isolamento come serializzabili.

BigQuery inoltre supporta le transazioni. BigQuery contribuisce a garantire il controllo della concorrenza ottimistico (la priorità è del primo commit) con l'isolamento tramite snapshot, in cui una query legge gli ultimi dati sottoposti a commit prima dell'inizio della query. Questo approccio garantisce lo stesso livello di coerenza su base per riga, per mutazione e tra righe all'interno della stessa istruzione DML, evitando al contempo i deadlock. Nella nel caso di più aggiornamenti DML rispetto alla stessa tabella, BigQuery passa a controllo pessimistico della contemporaneità. I job di caricamento possono essere eseguiti in modo completamente indipendente e aggiunti alle tabelle.

Esegui il rollback

Se Amazon Redshift rileva un errore durante l'esecuzione di una procedura memorizzata, annulla tutte le modifiche apportate in una transazione. Inoltre, puoi utilizzare la ROLLBACK un'istruzione di controllo delle transazioni in una stored procedure per ignorare tutte le modifiche.

In BigQuery, puoi utilizzare l'istruzione ROLLBACK TRANSACTION.

Limiti per i database

Consulta la documentazione pubblica di BigQuery per conoscere le quote e i limiti più recenti. Molte quote per utenti con volumi elevati possono essere aumentate contattando il team di assistenza di Cloud. La tabella seguente mostra un confronto dei limiti dei database Amazon Redshift e BigQuery.

Limite Amazon Redshift BigQuery
Tabelle in ogni database per i tipi di nodi di cluster large e xlarge 9.900 Senza restrizioni
Tabelle in ogni database per tipi di nodi cluster 8xlarge 20.000 Senza restrizioni
Database definiti dall'utente che puoi creare per ciascun cluster 60 Senza restrizioni
Dimensioni massime delle righe 4 MB 100 MB