Guida alla traduzione SQL di Amazon Redshift
Questo documento illustra le analogie e le differenze nella sintassi SQL tra Amazon Redshift e BigQuery per aiutarti a pianificare la migrazione. Utilizza la traduzione SQL batch per eseguire la migrazione collettiva degli script SQL o la traduzione SQL interattiva per tradurre le 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 |
SMALLINT di Amazon Redshift è di 2 byte, mentre INT64 di BigQuery è di 8 byte. |
INTEGER |
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 |
REAL di Amazon Redshift è di 4 byte, mentre FLOAT64 di BigQuery è di 8 byte. |
DOUBLE
PRECISION |
FLOAT64 |
||
BOOLEAN |
BOOL |
BOOL |
BOOLEAN di Amazon Redshift può utilizzare TRUE , t ,
true , y , yes e
1 come valori letterali validi per true. Il tipo di dato
BOOL di BigQuery è indipendente dalle maiuscole.
TRUE |
CHAR |
STRING |
||
VARCHAR |
STRING |
||
DATE |
DATE |
||
TIMESTAMP |
TIMESTAMP WITHOUT TIME ZONE |
DATETIME |
|
TIMESTAMPTZ |
TIMESTAMP |
Nota: in BigQuery, 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 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 | Al tipo BigQuery |
---|---|
|
|
|
|
|
|
BigQuery esegue anche conversioni implicite per i seguenti valori letterali:
Dal tipo BigQuery | Al tipo BigQuery |
---|---|
Valore letterale STRING (ad es. "2008-12-25") |
|
Valore letterale STRING (ad es. "2008-12-25 15:30:00") |
|
STRING letterale (ad es. "2008-12-25T07:30:00") |
|
STRING letterale (ad es. "15:30:00") |
|
Tipi di conversione espliciti
Puoi convertire i tipi di dati di Amazon Redshift che BigQuery non converte implicitamente utilizzando la funzione
CAST(expression AS type)
di BigQuery o una delle funzioni di conversione
DATE
e
TIMESTAMP
.
Durante la migrazione delle query, modifica le eventuali occorrenze della funzione
CONVERT(type, expression)
di Amazon Redshift (o della sintassi ::) con la funzione
CAST(expression AS type)
di BigQuery, come mostrato nella tabella della sezione Funzioni di formattazione dei tipi di dati.
Sintassi delle query
Questa sezione illustra le differenze nella sintassi delle query tra Amazon Redshift e BigQuery.
SELECT
dichiarazione
La maggior parte delle istruzioni
SELECT
di Amazon Redshift è compatibile con BigQuery. La tabella seguente contiene un elenco di
piccole differenze.
Amazon Redshift | BigQuery |
---|---|
|
|
|
|
BigQuery supporta anche le seguenti espressioni nelle istruzioni SELECT
, che non hanno un equivalente in 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 alle tabelle includono tabelle, visualizzazioni e sottoquery. Tutti
i riferimenti alle tabelle sono supportati in BigQuery.
È possibile fare riferimento alle tabelle BigQuery nella clausola FROM
utilizzando quanto segue:
[project_id].[dataset_id].[table_name]
[dataset_id].[table_name]
[table_name]
BigQuery supporta anche altri riferimenti alle tabelle:
- Versioni storiche della definizione della tabella e delle righe che utilizzano
FOR SYSTEM_TIME AS OF
. - Percorsi dei campi o qualsiasi percorso che risolve in un campo all'interno di un tipo di dati (ad esempio un
STRUCT
). - Array appiattiti.
Tipi di JOIN
Sia Amazon Redshift che BigQuery supportano i seguenti tipi di join:
[INNER] JOIN
LEFT [OUTER] JOIN
RIGHT [OUTER] JOIN
FULL [OUTER] JOIN
CROSS JOIN
e l'equivalente cross join con virgola implicita.
La tabella seguente contiene un elenco di differenze minori.
Amazon Redshift | BigQuery |
---|---|
|
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 differenze minori tra gli operatori di set di Amazon Redshift e gli operatori di set di BigQuery. Tuttavia, tutte le operazioni sugli insiemi possibili in Amazon Redshift sono replicabili in BigQuery.
Amazon Redshift | BigQuery |
---|---|
|
Nota: sia BigQuery che Amazon Redshift supportano l'operatore |
|
|
|
|
|
|
|
Nota: BigQuery richiede le parentesi per separare le diverse operazioni di set. 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 sono classificati per primi per impostazione predefinita
(ordine crescente). |
|
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. |
|
Nota: in BigQuery, OFFSET deve essere utilizzato insieme a un
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 di Amazon Redshift o i predicati specifici di Amazon Redshift che devono essere convertiti nel loro equivalente BigQuery.
Amazon Redshift | BigQuery |
---|---|
|
|
|
|
|
|
|
Nota: BigQuery non supporta i caratteri di escape personalizzati. Devi utilizzare due barre oblique \\ come caratteri di escape per BigQuery. |
|
Nota: se è specificato NOT , racchiudi l'espressione IF riportata sopra in un'espressione NOT come mostrato di seguito:
|
|
|
Funzioni
Le sezioni seguenti elencano le funzioni di Amazon Redshift e i relativi equivalenti in BigQuery.
Funzioni di aggregazione
La tabella seguente mostra le mappature tra le funzioni aggregate, aggregate analitiche e aggregate approssimative comuni di Amazon Redshift e i relativi equivalenti di BigQuery.
Amazon Redshift | BigQuery |
---|---|
APPROXIMATE
COUNT(DISTINCT expression) |
APPROX_COUNT_DISTINCT(expression) |
APPROXIMATE
PERCENTILE_DISC( |
APPROX_QUANTILES(expression,
100) |
AVG([DISTINCT] expression) |
AVG([DISTINCT] expression) |
COUNT(expression) |
COUNT(expression) |
LISTAGG( |
STRING_AGG( |
MAX(expression) |
MAX(expression) |
MEDIAN(median_expression) |
PERCENTILE_CONT( median_expression, 0.5
) OVER() |
MIN(expression) |
MIN(expression) |
PERCENTILE_CONT( |
PERCENTILE_CONT( Nota: non copre i casi d'uso di 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:
ANY_VALUE
APPROX_TOP_COUNT
APPROX_TOP_SUM
ARRAY_AGG
ARRAY_CONCAT_AGG
COUNTIF
CORR
COVAR_POP
COVAR_SAMP
Funzioni di aggregazione a livello di bit
La tabella seguente mostra le mappature tra le funzioni di aggregazione bitwise comuni di Amazon Redshift e i relativi equivalenti di 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 la seguente funzione di aggregazione a livello di bit, che non ha un analogo diretto in Amazon Redshift:
Funzioni finestra
La tabella seguente mostra le mappature tra le funzioni finestra comuni di Amazon Redshift con i relativi equivalenti di 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 |
AVG(expression) OVER |
COUNT(expression) OVER |
COUNT(expression) OVER |
CUME_DIST() OVER |
CUME_DIST() OVER |
DENSE_RANK() OVER |
DENSE_RANK() OVER |
FIRST_VALUE(expression)
OVER |
FIRST_VALUE(expression)
OVER |
LAST_VALUE(expression) OVER |
LAST_VALUE(expression) OVER |
LAG(value_expr [, offset])
OVER |
LAG(value_expr [, offset])
OVER |
LEAD(value_expr [, offset])
OVER |
LEAD(value_expr [, offset])
OVER |
LISTAGG( |
STRING_AGG( |
MAX(expression) OVER |
MAX(expression) OVER |
MEDIAN(median_expression)
OVER |
PERCENTILE_CONT( |
MIN(expression) OVER |
MIN(expression) OVER |
NTH_VALUE(expression,
offset) OVER (
[PARTITION BY window_partition] [ORDER BY window_ordering
frame_clause]
) |
NTH_VALUE(expression,
offset) OVER |
NTILE(expr) OVER |
NTILE(expr) OVER |
PERCENT_RANK() OVER |
PERCENT_RANK() OVER |
PERCENTILE_CONT(percentile)
|
PERCENTILE_CONT(expr,
percentile) OVER |
PERCENTILE_DISC(percentile)
WITHIN GROUP (ORDER BY expr) OVER |
PERCENTILE_DISC(expr,
percentile) OVER |
RANK() OVER |
RANK() OVER |
RATIO_TO_REPORT(ratio_expression)
OVER |
ratio_expression SUM(ratio_expression) OVER |
ROW_NUMBER() OVER |
ROW_NUMBER() OVER |
STDDEV(expression) OVER |
STDDEV(expression) OVER |
STDDEV_SAMP(expression)
OVER |
STDDEV_SAMP(expression)
OVER |
STDDEV_POP(expression) OVER |
STDDEV_POP(expression) OVER |
SUM(expression) OVER |
SUM(expression) OVER |
VAR_POP(expression) OVER |
VAR_POP(expression) OVER |
VAR_SAMP(expression) OVER |
VAR_SAMP(expression) OVER |
VARIANCE(expression) OVER |
VARIANCE(expression) OVER |
Espressioni condizionali
La tabella seguente mostra le mappature tra le espressioni condizionali comuni di Amazon Redshift e i relativi equivalenti di BigQuery.
Amazon Redshift | BigQuery |
---|---|
CASEexpression |
CASE expression |
COALESCE(expression1[,
...]) |
COALESCE(expression1[,
...]) |
DECODE( |
CASE expression |
GREATEST(value [,
...]) |
GREATEST(value [,
...]) |
LEAST(value [, ...]) |
LEAST(value [, ...]) |
NVL(expression1[, ...])
|
COALESCE(expression1[,
...]) |
NVL2( |
IF( |
NULLIF(expression1,
expression2) |
NULLIF(expression1,
expression2) |
BigQuery offre anche le seguenti espressioni condizionali, che non hanno un analogo 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. Le funzioni relative a dati e ora di BigQuery includono funzioni relative alla data, funzioni relative a data e ora functions, funzioni relative all'ora, e funzioni relative al 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( |
CAST( DATE_ADD( |
timestamptz_or_timestamp AT TIME
ZONE timezone |
PARSE_TIMESTAMP( Nota: i fusi orari vengono utilizzati durante l'analisi dei timestamp o la loro formattazione 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 la differenza rispetto a UTC (-HH:MM) sono supportati, ma le abbreviazioni dei fusi orari (ad esempio PDT) non sono supportate. |
CONVERT_TIMEZONE( |
PARSE_TIMESTAMP( Nota: source_timezone è UTC in BigQuery. |
CURRENT_DATE Nota: restituisce la data di inizio della transazione corrente nel fuso orario della sessione corrente (UTC per impostazione predefinita). |
CURRENT_DATE() Nota: restituisce la data di inizio dell'istruzione corrente nel fuso orario UTC. |
DATE_CMP(date1, date2)
|
CASE |
DATE_CMP_TIMESTAMP(date1,
date2) |
CASE |
DATE_CMP_TIMESTAMPTZ(date,
timestamptz) |
CASE |
DATE_PART_YEAR(date) |
EXTRACT(YEAR FROM
date) |
DATEADD(date_part,
interval, date) |
CAST( |
DATEDIFF( |
DATE_DIFF( |
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( |
INTERVAL_CMP( |
Per gli intervalli in Redshift, un anno è composto da 360 giorni.
In BigQuery, puoi utilizzare la seguente funzione definita dall'utente (UDF) per analizzare un intervallo Redshift e tradurlo in secondi. CREATE TEMP FUNCTION Per confrontare i valori letterali dell'intervallo, esegui: IF( |
LAST_DAY(date) |
DATE_SUB( |
MONTHS_BETWEEN( |
DATE_DIFF( |
NEXT_DAY(date, day) |
DATE_ADD( |
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( |
TIMESTAMP_CMP( |
CASE |
TIMESTAMP_CMP_DATE( |
CASE |
TIMESTAMP_CMP_TIMESTAMPTZ(
Nota: Redshift confronta i timestamp nel fuso orario definito dalla sessione utente. Il fuso orario predefinito della sessione utente è UTC. |
CASE Nota: BigQuery confronta i timestamp nel fuso orario UTC. |
TIMESTAMPTZ_CMP( Nota: Redshift confronta i timestamp nel fuso orario definito dalla sessione utente. Il fuso orario predefinito della sessione utente è UTC. |
CASE Nota: BigQuery confronta i timestamp nel fuso orario UTC. |
TIMESTAMPTZ_CMP_DATE( Nota: Redshift confronta i timestamp nel fuso orario definito dalla sessione utente. Il fuso orario predefinito della sessione utente è UTC. |
CASE Nota: BigQuery confronta i timestamp nel fuso orario UTC. |
TIMESTAMPTZ_CMP_TIMESTAMP(
Nota: Redshift confronta i timestamp nel fuso orario definito dalla sessione utente. Il fuso orario predefinito della sessione utente è UTC. |
CASE Nota: BigQuery confronta i timestamp nel fuso orario UTC. |
TIMEZONE( |
PARSE_TIMESTAMP( Nota: i fusi orari vengono utilizzati durante l'analisi dei timestamp o la loro formattazione 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 la differenza rispetto a UTC (-HH:MM) sono supportati, ma le abbreviazioni dei fusi orari (ad esempio PDT) non sono supportate. |
TO_TIMESTAMP(timestamp,
format) |
PARSE_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 lo spostamento rispetto a UTC (-HH:MM) sono supportati nella stringa di formato, ma le abbreviazioni dei fusi orari (ad es. 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:
EXTRACT
DATE
DATE_SUB
DATE_ADD
(che restituisceDATE
tipo di dati)DATE_FROM_UNIX_DATE
FORMAT_DATE
PARSE_DATE
UNIX_DATE
DATETIME
DATETIME_ADD
DATETIME_SUB
DATETIME_DIFF
DATETIME_TRUNC
FORMAT_DATETIME
PARSE_DATETIME
CURRENT_TIME
TIME
TIME_ADD
TIME_SUB
TIME_DIFF
TIME_TRUNC
FORMAT_TIME
PARSE_TIME
TIMESTAMP_SECONDS
TIMESTAMP_MILLIS
TIMESTAMP_MICROS
UNIX_SECONDS
UNIX_MILLIS
UNIX_MICROS
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 |
---|---|
|
|
|
|
|
|
Nota: se l'operatore esegue la divisione tra numeri interi (in altre parole, se X e
Y sono entrambi
numeri interi), viene restituito un numero intero. Se l'operatore esegue una divisione non intera, viene restituito un valore non intero. |
Se divisione intera: CAST(FLOOR(X / Y) AS INT64)
Se non divisione intera:
Nota: la divisione in BigQuery restituisce un valore non intero. Per evitare errori dovuti a un'operazione di divisione (errore di divisione per zero), utilizza SAFE_DIVIDE(X, Y) o
IEEE_DIVIDE(X, Y) . |
|
Nota: per evitare errori di un'operazione di divisione (errore di divisione per zero), utilizza SAFE.MOD(X, Y) . SAFE.MOD(X, 0) risultati in 0. |
|
Nota: a differenza di Amazon Redshift, l'operatore ^ in
BigQuery esegue l'operazione XOR di bitwise. |
|
Nota: per evitare errori dovuti a un'operazione di radice quadrata (input negativo), utilizza SAFE.SQRT(X) . Un input negativo
con SAFE.SQRT(X) genera
NULL . |
|
Nota: la funzione POWER(X, Y) di BigQuery restituisce un
errore se X è un valore finito minore di 0
e Y non è un numero intero. |
|
|
|
Nota: 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. |
|
Nota: sposta il primo operando X verso destra. Questo operatore non esegue l'estensione del bit di segno con un tipo con segno (compila i bit vuoti a sinistra 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. |
|
|
|
|
|
|
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 |
BTRIM(string [,
matching_string]) |
TRIM(string [,
matching_string]) |
BTTEXT_PATTERN_CMP(string1,
string2) |
CASE |
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 definita dall'utente 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 |
ARRAY_LENGTH( REGEXP_EXTRACT_ALL( Se è specificato position : ARRAY_LENGTH( REGEXP_EXTRACT_ALL( Nota: BigQuery fornisce il supporto delle espressioni regolari utilizzando la libreria re2 ; consulta la relativa documentazione per la sintassi delle espressioni regolari. |
REGEXP_INSTR( |
IFNULL( STRPOS( Se è specificato source_string : REGEXP_REPLACE( Se è specificato position :IFNULL( STRPOS( Se è specificato occurrence :IFNULL( STRPOS( Nota: BigQuery fornisce il supporto delle espressioni regolari utilizzando la libreria re2
; consulta la documentazione per la sintassi delle espressioni regolari . |
REGEXP_REPLACE(
source_string, |
REGEXP_REPLACE( Se è specificato source_string :
REGEXP_REPLACE( Se è specificato position :CASE |
REGEXP_SUBSTR(
source_string, pattern |
REGEXP_EXTRACT( Se è specificato position :REGEXP_EXTRACT( Se è specificato occurrence :REGEXP_EXTRACT_ALL( 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( |
STRPOS(string,
substring) |
STRPOS(string,
substring) |
STRTOL(string, base) |
|
SUBSTRING( |
SUBSTR( |
TEXTLEN(expression) |
LENGTH(expression) |
TRANSLATE( |
Può essere implementato utilizzando le funzioni definite dall'utente: CREATE TEMP FUNCTION |
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(
|
FORMAT_TIMESTAMP( Nota: BigQuery e Amazon Redshift differiscono per la modalità di specifica di una stringa di formato per timestamp_expression . |
TO_CHAR(
|
FORMAT( 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( 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 un trasferimento. Ad 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.
INSERT
dichiarazione
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 [, ...]) |
INSERT [INTO] table (column1 [, ...]) |
INSERT INTO table (column1, [,...]) VALUES ( |
INSERT [INTO] table (column1, [,...]) |
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 una delle diverse opzioni e degli strumenti non SQL per caricare i dati nelle 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 |
UPDATE table Nota: tutte le istruzioni UPDATE in BigQuery richiedono una parola chiave WHERE , followed by a condition. |
UPDATE table |
UPDATE table 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 ulteriori informazioni su DELETE
in BigQuery, consulta gli esempi di DELETE
di BigQuery nella documentazione DML.
Amazon Redshift | BigQuery |
---|---|
DELETE
[FROM] table_name TRUNCATE
[TABLE] table_name |
DELETE FROM table_name Le istruzioni DELETE di BigQuery richiedono una
clausola WHERE . |
DELETE FROM table_name |
DELETE FROM table_name DELETE FROM table_name In Amazon Redshift, USING consente di fare riferimento a tabelle aggiuntive nella clausola WHERE . Questo risultato può essere ottenuto in
BigQuery utilizzando una sottoquery nella
clausola WHERE . |
MERGE
dichiarazione
L'istruzione MERGE
può combinare le operazioni INSERT
, UPDATE
e DELETE
in un'unica istruzione upsert ed eseguire le operazioni in modo atomico. L'operazione MERGE
deve corrispondere a un massimo di una riga di origine per ogni riga di destinazione.
Amazon Redshift non supporta un singolo comando MERGE
. Tuttavia, in Amazon Redshift è possibile eseguire un'operazione di unione mediante le operazioni INSERT
, UPDATE
e DELETE
in una transazione.
Operazione di unione mediante sostituzione delle 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
. L'istruzione DELETE
rimuove le righe che devono essere aggiornate, quindi l'istruzione INSERT
inserisce le righe aggiornate. Le tabelle BigQuery sono limitate a 1000 istruzioni DML al giorno, quindi devi unificare le istruzioni INSERT
, UPDATE
e DELETE
in un'unica istruzione MERGE
, come mostrato nella tabella seguente.
Amazon Redshift | BigQuery |
---|---|
Consulta Eseguire un'operazione di associazione sostituendo le righe esistenti. CREATE TEMP TABLE temp_table; |
MERGE target Nota: se vuoi aggiornare tutte le colonne, devono essere elencate tutte. |
Consulta Eseguire un'operazione di associazione specificando un elenco di colonne. CREATE TEMP TABLE temp_table; |
MERGE target |
Sintassi DDL
Questa sezione illustra le differenze nella sintassi del linguaggio di definizione dei dati tra Amazon Redshift e BigQuery.
SELECT INTO
dichiarazione
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 |
INSERT table |
WITH subquery_table AS ( SELECT ... |
INSERT table |
SELECT expression |
BigQuery offre diversi modi per emulare le tabelle temporanee. Per ulteriori informazioni, consulta la sezione Tabelle temporanee. |
CREATE TABLE
dichiarazione
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 ( Nota: i vincoli UNIQUE e PRIMARY KEY sono di carattere informativo e non vengono applicati dal sistema Amazon Redshift. |
CREATE TABLE table_name ( |
CREATE TABLE table_name Nota: i vincoli UNIQUE e PRIMARY KEY sono informativi e non vengono applicati dal sistema Amazon Redshift.
|
CREATE TABLE table_name Nota: BigQuery non utilizza i vincoli di tabella UNIQUE , PRIMARY KEY o FOREIGN KEY . Per ottenere un'ottimizzazione simile a quella fornita da questi vincoli durante l'esecuzione delle query,
partiziona e raggruppa le tabelle BigQuery. CLUSTER BY supporta fino a
4 colonne. |
CREATE TABLE 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 Nota: in Amazon Redshift, l'impostazione BACKUP
NO viene specificata per risparmiare tempo di elaborazione e ridurre lo spazio di archiviazione. |
L'opzione tabella BACKUP NO non viene utilizzata o non è necessaria perché BigQuery conserva automaticamente fino a 7 giorni di versioni storiche di tutte le tue tabelle senza influire sul tempo di elaborazione o sullo spazio di archiviazione fatturato.
|
CREATE TABLE table_name |
BigQuery supporta il clustering, che consente di memorizzare le chiavi in ordine alfabetico. |
CREATE TABLE table_name |
CREATE TABLE table_name |
CREATE TABLE IF NOT EXISTS table_name ... |
CREATE TABLE IF NOT EXISTS |
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 ulteriori informazioni su CREATE TABLE
in BigQuery, consulta gli esempi di CREATE TABLE
di BigQuery nella documentazione DML.
Tabelle temporanee
Amazon Redshift supporta le tabelle temporanee, che sono visibili solo all'interno della sessione corrente. Esistono diversi modi per emulare le tabelle temporanee in BigQuery:
- TTL del set di dati: crea un set di dati con una durata breve (ad esempio un'ora) in modo che le tabelle create nel set di dati siano effettivamente temporanee perché non rimarranno più a lungo della durata del set di dati. 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 l'istruzione
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 |
CREATE VIEW view_name |
CREATE VIEW view_name AS SELECT
... |
Non supportati. | CREATE VIEW IF NOT EXISTS c
view_name Crea una nuova vista solo se non esiste nel set di dati specificato. |
CREATE VIEW view_name In Amazon Redshift è necessaria una vista con il binding tardivo per fare riferimento a una tabella esterna. |
In BigQuery, per creare una vista, tutti gli oggetti a cui si fa 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, eseguono azioni e restituiscono il risultato di queste azioni come valore.
Sia Amazon Redshift che BigQuery supportano le funzioni definite dall'utente che utilizzano espressioni SQL. Inoltre, in Amazon Redshift puoi creare una UDF basata su Python, mentre in BigQuery puoi creare una 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 |
CREATE [OR REPLACE] FUNCTION Nota: in una funzione UDF SQL di BigQuery, un tipo di dato restituito è facoltativo. BigQuery deducono il tipo di risultato della funzione dal corpo della funzione SQL quando una query chiama la funzione. |
CREATE [OR
REPLACE] FUNCTION |
CREATE [OR REPLACE] FUNCTION Nota: la volatilità delle funzioni non è un parametro configurabile in BigQuery. Tutta la volatilità delle funzioni UDF di BigQuery è equivalente alla volatilità IMMUTABLE di Amazon Redshift (ovvero non esegue ricerche nel database o
altrimenti utilizza informazioni non direttamente presenti nell'elenco degli argomenti).
|
CREATE [OR
REPLACE] FUNCTION Nota: Amazon Redshift supporta solo una clausola SQL SELECT come definizione di funzione. Inoltre, la clausola SELECT non può includere le clausole FROM,
INTO, WHERE, GROUP BY, ORDER BY, e LIMIT . |
CREATE [OR REPLACE] FUNCTION Nota: BigQuery supporta qualsiasi espressione SQL come definizione di funzione. Tuttavia, i riferimenti a tabelle, visualizzazioni o modelli non sono supportati. |
CREATE [OR
REPLACE] FUNCTION |
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 UDF GoogleSQL. BigQuery interpreta l'espressione SQL per impostazione predefinita. Inoltre, le virgolette dollaro di Amazon Redshift ( $$ ) is not supported in BigQuery. |
CREATE [OR
REPLACE] FUNCTION function_name (integer, integer) RETURNS
integer IMMUTABLE AS $$ SELECT $1 + $2 $$ LANGUAGE sql |
CREATE [OR REPLACE] FUNCTION 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 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 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 |
DROP FUNCTION Note: BigQuery does not require using the function's signature for deleting the function. Also, removing function dependencies is not supported in BigQuery. |
BigQuery also supports the
DROP FUNCTION IF EXISTS
statement,
which deletes the function only if the function exists in the specified
dataset.
BigQuery requires that you specify the project_name
if the function is not located in the current project.
UDF components
This section highlights the similarities and differences in UDF components between Amazon Redshift andBigQuery.
Component | Amazon Redshift | BigQuery |
---|---|---|
Name | Amazon Redshift recommends using the prefix
_f for function names to avoid conflicts with existing
or future built-in SQL function names. |
In BigQuery, you can use any custom function name. |
Arguments | Arguments are optional. You can use name and data types for Python
UDF arguments and only data types for SQL UDF arguments. In SQL UDFs,
you must refer to arguments using $1 , $2 ,
and so on. Amazon Redshift also restricts
the number of arguments to 32. |
Arguments are optional, but if you specify arguments, they must use both name and data types for both JavaScript and SQL UDFs. The maximum number of arguments for a persistent UDF is 256. |
Data type | Amazon Redshift supports a different set of data types for SQL
and Python UDFs. For a Python UDF, the data type might also be ANYELEMENT .You must specify a RETURN data type for both SQL and
Python UDFs.See Data types in this document for equivalents between data types in Amazon Redshift and in BigQuery. |
BigQuery supports a different set of data types for SQL and JavaScript UDFs. For a SQL UDF, the data type might also be ANY TYPE . For
more information, see templated parameters in
BigQuery.The RETURN data type is optional for SQL UDFs.See Supported JavaScript UDF data types for information on how BigQuery data types map to JavaScript data types. |
Definition | For both SQL and Python UDFs, you must enclose the function
definition using dollar quoting, as in a pair of dollar signs
($$ ) per indicare l'inizio e la fine delle istruzioni della funzione.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 supporta il riferimento a tabelle, viste o modelli. Per le funzioni definite dall'utente JavaScript, puoi includere librerie di codice esterne direttamente utilizzando la sezione OPTIONS . Puoi anche utilizzare lo strumento di test delle funzioni UDF di BigQuery per testare le funzioni. |
Lingua | Devi utilizzare il valore letterale LANGUAGE per specificare il linguaggio come sql per le funzioni definite dall'utente SQL o plpythonu
per le funzioni definite dall'utente Python. |
Non è necessario specificare LANGUAGE per le funzioni definite dall'utente SQL, ma devi
specificare il linguaggio come js per le funzioni definite dall'utente JavaScript. |
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 definite dall'utente sia permanenti che temporanee. Puoi riutilizzare
le funzioni definite dall'utente permanenti per più query, mentre puoi utilizzare
solo le funzioni definite dall'utente temporanee in una singola query. La volatilità delle funzioni 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 viene 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. Questa operazione può essere gestita utilizzando Cloud IAM. |
Limiti | Consulta la sezione Limiti delle funzioni UDF di Python. | Consulta i limiti per le funzioni definite dall'utente. |
Istruzioni SQL per metadati e transazioni
Amazon Redshift | BigQuery |
---|---|
SELECT * FROM STL_ANALYZE WHERE name |
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 ... |
BigQuery utilizza l'isolamento degli snapshot. Per maggiori dettagli, vedi Garanzia di coerenza. |
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 |
SELECT * EXCEPT(is_typed) FROM Per ulteriori informazioni, consulta Introduzione a BigQuery INFORMATION_SCHEMA . |
VACUUM
[table_name] |
Non utilizzato in BigQuery. Le tabelle clusterizzate di BigQuery sono ordinate automaticamente. |
Istruzioni SQL con più istruzioni e su più righe
Sia Amazon Redshift che BigQuery supportano le transazioni (sessioni) e quindi supportano le istruzioni separate da punti e virgola che vengono eseguite insieme in modo coerente. 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 è obbligatorio un nome.In caso contrario, utilizza 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, un errore rilevato durante l'esecuzione di una procedura memorizzata interrompe il flusso di esecuzione, termina la transazione ed esegue il rollback della transazione.
Questi risultati si verificano perché le sottotransazioni non sono supportate. In una procedura memorizzata di Amazon Redshift, l'unico handler_statement
supportato è 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 |
Dichiarazioni e operazioni del cursore
Poiché BigQuery non supporta cursori o sessioni, le seguenti istruzioni non vengono utilizzate in BigQuery:
DECLARE
cursor_name
CURSOR
[FOR] ...
PREPARE
plan_name [ (datatype [, ...] ) ] AS statement
OPEN
cursor_name FOR SELECT ...
FETCH
[ NEXT | ALL | {FORWARD [ count | ALL ] } ] FROM cursor_name
CLOSE
cursor_name;
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 nella tabella seguente.
Amazon Redshift | BigQuery |
---|---|
EXECUTE |
EXECUTE IMMEDIATE |
Istruzioni di controllo del flusso
Amazon Redshift | BigQuery |
---|---|
IF..THEN..ELSIF..THEN..ELSE..END
IF |
IF condition |
name CURSOR
[ ( arguments ) ] FOR query |
I cursori o le sessioni non vengono utilizzati in BigQuery. |
[< |
LOOP |
WHILE
condition LOOP stmts END LOOP |
WHILE condition |
EXIT |
BREAK |
Garanzie di coerenza e isolamento delle transazioni
Sia Amazon Redshift che BigQuery sono atomici, ovvero conformi allo standard ACID a livello di mutazione su molte 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 supporta inoltre le transazioni. BigQuery contribuisce a garantire il controllo della concorrenza ottimistico (ha la priorità chi esegue per primo il 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. Nel caso di più aggiornamenti DML nella stessa tabella, BigQuery passa al controllo della concorrenza pessimistico. 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 l'istruzione di controllo transazioni ROLLBACK
in una procedura memorizzata 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 | 9900 | Senza restrizioni |
Tabelle in ogni database per i tipi di nodi del cluster 8xlarge | 20.000 | Senza restrizioni |
Database definiti dall'utente che puoi creare per ogni cluster | 60 | Senza restrizioni |
Dimensioni massime delle righe | 4 MB | 100 MB |