Guida alla traduzione SQL di Amazon Redshift
Questo documento descrive le analogie e le differenze nella sintassi SQL tra Amazon Redshift e BigQuery per aiutarti a pianificare la migrazione. Utilizza la traduzione SQL in gruppo per eseguire la migrazione collettiva degli script SQL oppure la traduzione SQL interattiva per tradurre le query ad hoc.
Il pubblico di destinazione di questa guida è costituito da enterprise architect, amministratori di database, sviluppatori di applicazioni e specialisti della sicurezza informatica. Presuppone che tu abbia familiarità 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 | Notes | |
---|---|---|---|
Tipo di dati | Alias | Tipo di dati | |
SMALLINT |
INT2 |
INT64 |
Il valore SMALLINT di Amazon Redshift è di 2 byte, mentre il valore INT64 di
BigQuery è di 8 byte. |
INTEGER |
INT64 |
Il valore INTEGER di Amazon Redshift è di 4 byte, mentre il valore INT64 di
BigQuery è di 8 byte. |
|
BIGINT |
INT8 |
INT64 |
I valori BIGINT di Amazon Redshift e INT64 di BigQuery sono entrambi a 8 byte. |
DECIMAL |
NUMERIC |
NUMERIC |
|
REAL |
FLOAT4 |
FLOAT64 |
Il valore REAL di Amazon Redshift è di 4 byte, mentre il valore 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 dati BOOL di BigQuery utilizza TRUE senza distinzione tra maiuscole e minuscole. |
CHAR |
STRING |
||
VARCHAR |
STRING |
||
DATE |
DATE |
||
TIMESTAMP |
TIMESTAMP WITHOUT TIME ZONE |
DATETIME |
|
TIMESTAMPTZ |
TIMESTAMP |
Nota: in BigQuery, i fusi orari vengono utilizzati durante l'analisi dei timestamp o della formattazione dei timestamp per la visualizzazione. Un timestamp nel formato stringa potrebbe includere un fuso orario, ma quando BigQuery analizza la stringa lo memorizza nell'ora UTC equivalente. Quando un fuso orario non è specificato in modo esplicito, viene utilizzato il fuso orario predefinito, UTC. Sono supportati i nomi dei fusi orari o l'offset rispetto all'UTC utilizzando (-|+)HH:MM, mentre le abbreviazioni dei fusi orari, ad esempio PDT, non sono supportate. | |
GEOMETRY |
GEOGRAPHY |
Supporto per l'esecuzione di query sui dati geospaziali. |
BigQuery include inoltre i seguenti tipi di dati che non hanno un analogico diretto di Amazon Redshift:
Tipi di conversione implicita
Quando esegui 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 vengono convertiti in modo implicito da BigQuery.
BigQuery esegue conversioni implicite per i seguenti tipi di dati:
Dal tipo BigQuery | Al tipo di BigQuery |
---|---|
|
|
|
|
|
|
BigQuery esegue anche conversioni implicite per i seguenti valori letterali:
Dal tipo BigQuery | Al tipo di BigQuery |
---|---|
STRING valore letterale (ad es. "25/12/2008") |
|
STRING valore letterale (ad es. "2008-12-25 15:30:00") |
|
STRING valore letterale (ad es. "2008-12-25T07:30:00") |
|
STRING valore letterale (ad es. "15:30:00") |
|
Tipi di conversione esplicita
Puoi convertire tipi di dati di Amazon Redshift che BigQuery non converte implicitamente
utilizzando la funzione
CAST(expression AS type)
di BigQuery
o una qualsiasi delle funzioni
di conversione di
DATE
e
TIMESTAMP
.
Quando esegui la migrazione delle query, modifica tutte le occorrenze della funzione Amazon Redshift CONVERT(type, expression)
(o la sintassi ::) nella funzione CAST(expression AS type)
di BigQuery, come mostrato nella tabella nella sezione Funzioni di formattazione del tipo di dati.
Sintassi delle query
Questa sezione illustra le differenze nella sintassi delle query tra Amazon Redshift e BigQuery.
Istruzione SELECT
La maggior parte delle istruzioni SELECT
di Amazon Redshift è compatibile con BigQuery. La seguente tabella contiene un elenco di
differenze di minore entità.
Amazon Redshift | BigQuery |
---|---|
|
|
|
|
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 nella tabella da cui vengono selezionati i dati. In Amazon Redshift, i possibili riferimenti alle tabelle includono tabelle, viste e sottoquery. Tutti questi 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 riferimenti aggiuntivi alle tabelle:
- Versioni storiche della definizione della tabella e delle righe che utilizzano
FOR SYSTEM_TIME AS OF
. - Percorsi di campo o qualsiasi percorso che si risolve in un campo all'interno di un tipo di dati (ad esempio
STRUCT
). - Array appiattiti:
JOIN
tipo
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 unione incrociata a virgola implicita.
La tabella seguente contiene un elenco delle differenze minori.
Amazon Redshift | BigQuery |
---|---|
|
Nota: in BigQuery, le clausole JOIN richiedono una
condizione JOIN , a meno che la clausola non sia un CROSS
JOIN o una delle tabelle unite non sia un campo all'interno di un
tipo di dati o di un array. |
Clausola WITH
Una clausola BigQuery WITH
contiene una o più sottoquery denominate che vengono eseguite quando un'istruzione SELECT
successiva vi fa riferimento. Le clausole di Amazon Redshift WITH
si comportano come quelle di BigQuery, con l'eccezione che puoi valutare la clausola una sola volta e riutilizzarne i risultati.
Operatori Set
Esistono alcune piccole differenze tra gli operatori dei set Amazon Redshift e gli operatori dei set BigQuery. Tuttavia, tutte le operazioni di set attuabili in Amazon Redshift sono replicabili in BigQuery.
Amazon Redshift | BigQuery |
---|---|
|
Nota: BigQuery e Amazon Redshift supportano l'operatore |
|
|
|
|
|
|
|
Nota: BigQuery richiede parentesi per separare le diverse operazioni dei set. Se lo stesso operatore di impostazione viene ripetuto, le parentesi non sono necessarie. |
Clausola ORDER BY
Esistono alcune piccole differenze tra le clausole di Amazon Redshift ORDER BY
e le clausole di BigQuery ORDER BY
.
Amazon Redshift | BigQuery |
---|---|
In Amazon Redshift, gli elementi NULL sono classificati all'ultimo per impostazione predefinita (ordine crescente). |
In BigQuery, gli elementi NULL sono classificati al primo per impostazione predefinita (ordine crescente). |
|
Nota: BigQuery non utilizza la sintassi LIMIT ALL , ma
ORDER BY ordina tutte le righe per impostazione predefinita, ottenendo lo stesso comportamento della clausola LIMIT ALL di Amazon Redshift. Ti consigliamo vivamente di includere una clausola LIMIT in ogni clausola ORDER BY . L'ordinamento di tutte le righe dei risultati
deteriora inutilmente le prestazioni di esecuzione della query. |
|
Nota: in BigQuery, OFFSET deve essere utilizzato insieme a un
LIMIT count. Assicurati di impostare il valore count
INT64 sul valore minimo di righe ordinate necessarie.
L'ordinamento di tutte le righe di risultati riduce inutilmente le prestazioni di esecuzione della query. |
Condizioni
La seguente tabella mostra le condizioni di Amazon Redshift, o i predicati, specifiche di Amazon Redshift e che devono essere convertite nell'equivalente BigQuery.
Amazon Redshift | BigQuery |
---|---|
|
|
|
|
|
|
|
Nota: BigQuery non supporta i caratteri di escape personalizzati. Devi utilizzare due barre rovesciate \\ come caratteri di escape per BigQuery. |
|
Nota: se NOT è specificato, esegui il wrapping dell'espressione
IF sopra in un'espressione NOT come mostrato
di seguito:
|
|
|
Funzioni
Le seguenti sezioni elencano le funzioni di Amazon Redshift e i relativi equivalenti BigQuery.
Funzioni di aggregazione
La seguente tabella mostra le mappature tra le funzioni di aggregazione comuni di Amazon Redshift, di aggregazione e di aggregazione approssimativa con i relativi equivalenti 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 riguarda i casi d'uso dell'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 inoltre le seguenti funzioni aggregate, dati aggregati e aggregazioni approssimative 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 seguente tabella mostra le mappature tra le funzioni comuni di aggregazione di Amazon Redshift bit per bit con i relativi equivalenti BigQuery.
Amazon Redshift | BigQuery |
---|---|
BIT_AND(expression) |
BIT_ADD(expression) |
BIT_OR(expression) |
BIT_OR(expression) |
BOOL_AND>(expression) |
LOGICAL_AND(expression) |
BOOL_OR(expression) |
LOGICAL_OR(expression) |
BigQuery offre anche la seguente funzione di aggregazione bit per bit, che non ha un analogo diretto in Amazon Redshift:
Funzioni finestra
La seguente tabella mostra le mappature tra le funzioni comuni delle finestre di Amazon Redshift e gli equivalenti BigQuery. Le funzioni di windowing in BigQuery includono funzioni aggregate analitiche, funzioni aggregate, 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 seguente tabella mostra le mappature tra le espressioni condizionali comuni di Amazon Redshift con i relativi equivalenti 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 analogico diretto in Amazon Redshift:
Funzioni di data e ora
La seguente tabella mostra le mappature tra le funzioni di data e ora comuni di Amazon Redshift e i relativi equivalenti BigQuery. I dati e le funzioni temporali di BigQuery includono funzioni di data, funzioni datetime, funzioni temporali e funzioni di timestamp.
Tieni presente che 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 per l'analisi dei timestamp o della formattazione dei timestamp per la visualizzazione. Un timestamp nel formato stringa potrebbe includere un fuso orario, ma quando BigQuery analizza la stringa lo memorizza nell'ora UTC equivalente. Quando un fuso orario non è specificato in modo esplicito, viene utilizzato il fuso orario predefinito, UTC. I nomi dei fusi orari o l'offset rispetto al fuso orario UTC (-HH:MM) sono supportati, ma le abbreviazioni dei fusi orari (ad esempio PDT) non lo sono. |
CONVERT_TIMEZONE( |
PARSE_TIMESTAMP( Nota: il fuso orario source_timezone è UTC in BigQuery. |
CURRENT_DATE Nota: restituisce la data di inizio della transazione corrente nel fuso orario attuale della sessione (per impostazione predefinita UTC). |
CURRENT_DATE() Nota: restituisce la data di inizio per l'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, ci sono 360 giorni in un anno.
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 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 (per impostazione predefinita UTC). |
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 dell'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 dell'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 dell'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 dell'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 per l'analisi dei timestamp o della formattazione dei timestamp per la visualizzazione. Un timestamp nel formato stringa potrebbe includere un fuso orario, ma quando BigQuery analizza la stringa lo memorizza nell'ora UTC equivalente. Quando un fuso orario non è specificato in modo esplicito, viene utilizzato il fuso orario predefinito, UTC. I nomi dei fusi orari o l'offset rispetto al fuso orario UTC (-HH:MM) sono supportati, mentre le abbreviazioni dei fusi orari (ad esempio PDT) non lo sono. |
TO_TIMESTAMP(timestamp,
format) |
PARSE_TIMESTAMP( Nota: BigQuery segue un insieme diverso di elementi di formato. I fusi orari vengono utilizzati durante l'analisi dei timestamp o la formattazione dei timestamp per la visualizzazione. Un timestamp nel formato stringa potrebbe includere un fuso orario, ma quando BigQuery analizza la stringa lo memorizza nell'ora UTC equivalente. Quando un fuso orario non è specificato in modo esplicito, viene utilizzato il fuso orario predefinito, UTC. I nomi dei fusi orari o l'offset da UTC (-HH:MM) sono supportati nella stringa di formato, ma le abbreviazioni dei fusi orari (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:
EXTRACT
DATE
DATE_SUB
DATE_ADD
(tipo di datiDATE
restituito)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 seguente tabella mostra le mappature tra gli operatori matematici più comuni di Amazon Redshift e i relativi equivalenti BigQuery.
Amazon Redshift | BigQuery |
---|---|
|
|
|
|
|
|
Nota: se l'operatore esegue la divisione intera (in altre parole, se X e Y sono entrambi numeri interi), viene restituito un numero intero. Se l'operatore esegue una divisione non numero intero, viene restituito un numero non intero. |
Se la divisione con un numero intero: CAST(FLOOR(X / Y) AS INT64)
Se non la divisione con un numero intero:
Nota: la divisione in BigQuery restituisce un numero non intero. Per evitare errori da un'operazione di divisione (divisione per zero errori), utilizza SAFE_DIVIDE(X, Y) oppure IEEE_DIVIDE(X, Y) . |
|
Nota: per evitare errori da un'operazione di divisione (errore di divisione per zero), utilizza SAFE.MOD(X, Y) . SAFE.MOD(X, 0) restituisce 0. |
|
Nota: a differenza di Amazon Redshift, l'operatore ^ in BigQuery esegue Bitwise Xor. |
|
Nota: per evitare errori da un'operazione radice quadrata (input negativo), utilizza SAFE.SQRT(X) . Input negativo
con SAFE.SQRT(X) restituisce
NULL . |
|
Nota: POWER(X, Y) di BigQuery restituisce un
errore se X è un valore finito inferiore a 0
e Y non è un numero intero. |
|
|
|
Nota: questo operatore restituisce 0 o una sequenza di byte b'\x00' se il secondo operando Y è maggiore o uguale alla lunghezza in bit del
primo operando X (ad esempio, 64 se X ha il tipo INT64). Questo operatore genera un errore se Y è negativo. |
|
Nota: sposta il primo operando X verso destra. Questo operatore non esegue la firma dell'estensione di bit con un tipo firmato (riempie i bit vacanti 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 ha il tipo INT64). Questo operatore genera un errore se Y è negativo. |
|
|
|
|
|
|
BigQuery offre anche il seguente operatore matematico, che non dispone di un analogico diretto in Amazon Redshift:
X ^ Y
(Xor bit a 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 concatenare qualsiasi numero 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 position è specificato: ARRAY_LENGTH( REGEXP_EXTRACT_ALL( Nota: BigQuery supporta le espressioni regolari utilizzando la libreria re2 . Consulta la documentazione per conoscere la sintassi delle espressioni regolari. |
REGEXP_INSTR( |
IFNULL( STRPOS( Se source_string è specificato: REGEXP_REPLACE( Se position è specificato:IFNULL( STRPOS( Se occurrence è specificato:IFNULL( STRPOS( Nota: BigQuery fornisce il supporto delle espressioni regolari utilizzando la libreria re2 ; consulta la documentazione di per la sintassi dell'espressione regolare . |
REGEXP_REPLACE(
source_string, |
REGEXP_REPLACE( Se source_string è specificato:
REGEXP_REPLACE( Se position è specificato:CASE |
REGEXP_SUBSTR(
source_string, pattern |
REGEXP_EXTRACT( Se position è specificato:REGEXP_EXTRACT( Se occurrence è specificato:REGEXP_EXTRACT_ALL( Nota: BigQuery supporta le espressioni regolari utilizzando la libreria re2 . Consulta la documentazione sulla 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 nel modo in cui specificare una stringa di formato per timestamp_expression . |
TO_CHAR(
|
FORMAT( Nota: BigQuery e Amazon Redshift differiscono nel modo in cui specificare una stringa di formato per timestamp_expression .
|
TO_DATE(date_string, format) |
PARSE_DATE(date_string, format)
Nota: BigQuery e Amazon Redshift differiscono nel modo di specificare una stringa di formato per date_string . |
TO_NUMBER(string, format) |
CAST( Nota: BigQuery e Amazon Redshift differiscono nel modo di specificare 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; ad esempio,
SAFE_CAST
("apple"
AS INT64)
restituisce NULL
.
Sintassi DML
Questa sezione descrive 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 null è NULL
e DEFAULT
non è supportato per le colonne obbligatorie. La maggior parte delle istruzioni 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 tramite una sottoquery (in cui uno dei valori viene calcolato utilizzando una sottoquery), che non è supportata in Amazon Redshift. Ad esempio:
INSERT INTO table (column1, column2)
VALUES ('value_1', (
SELECT column2
FROM table2
))
Istruzione COPY
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 diversi strumenti e opzioni non SQL per caricare i dati nelle tabelle BigQuery.
Puoi anche utilizzare i sink di pipeline di dati forniti in Apache Spark o Apache Beam per scrivere dati in BigQuery.
Istruzione UPDATE
La maggior parte delle istruzioni UPDATE
di Amazon Redshift è compatibile con BigQuery. La seguente tabella mostra le eccezioni.
Amazon Redshift | BigQuery |
---|---|
UPDATE table |
UPDATE table Nota: tutte le istruzioni UPDATE in BigQuery richiedono una parola chiave WHERE ,
seguita da una condizione. |
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 . |
Estratti conto DELETE
e TRUNCATE
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 prima di un'istruzione DELETE
non qualificata perché è più veloce 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 di DML.
Amazon Redshift | BigQuery |
---|---|
DELETE
[FROM] table_name TRUNCATE
[TABLE] table_name |
DELETE FROM table_name Le istruzioni BigQuery DELETE 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 . Può essere eseguito in BigQuery utilizzando una sottoquery nella clausola WHERE . |
Istruzione MERGE
L'istruzione MERGE
può combinare le operazioni INSERT
, UPDATE
e DELETE
in una
singola istruzione upsert ed eseguire le operazioni a livello atomico. L'operazione MERGE
deve corrispondere al massimo a una riga di origine per ogni riga di destinazione.
Amazon Redshift non supporta un singolo comando MERGE
. Tuttavia,
è possibile eseguire un'operazione di unione
in Amazon Redshift eseguendo operazioni
INSERT
, UPDATE
e DELETE
in una transazione.
Operazione di unione sostituendo le righe esistenti
In Amazon Redshift, è possibile eseguire una sovrascrittura di tutte le colonne nella tabella di destinazione utilizzando un'istruzione DELETE
e poi un'istruzione INSERT
. L'istruzione DELETE
rimuove le righe che devono essere aggiornate, dopodiché l'istruzione INSERT
inserisce le righe aggiornate. Le tabelle BigQuery sono limitate a
1000 istruzioni DML al giorno, quindi è necessario consolidare le istruzioni INSERT
, UPDATE
e DELETE
in una
singola istruzione MERGE
, come mostrato nella seguente tabella.
Amazon Redshift | BigQuery |
---|---|
Consulta Eseguire un'operazione di unione sostituendo le righe esistenti. CREATE TEMP TABLE temp_table; |
MERGE target Nota: se aggiorni tutte le colonne, devono essere elencate tutte le colonne. |
Vedi Eseguire un'operazione di unione 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.
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 creazione e inserimento di tabelle.
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 sulle tabelle temporanee. |
Istruzione CREATE TABLE
La maggior parte delle istruzioni CREATE TABLE
di Amazon Redshift è 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
informativi e non sono
applicati dal sistema Amazon Redshift. |
CREATE TABLE table_name ( |
CREATE TABLE table_name Nota: i vincoli UNIQUE e PRIMARY KEY sono informativi e non sono applicati dal sistema Amazon Redshift.
|
CREATE TABLE table_name Nota: BigQuery non utilizza i vincoli delle tabelle UNIQUE , PRIMARY KEY o FOREIGN KEY . Per ottenere un'ottimizzazione simile a quella fornita da questi vincoli durante l'esecuzione delle query, partiziona e assegna il cluster alle tabelle BigQuery. CLUSTER BY supporta fino a
4 colonne. |
CREATE TABLE table_name |
Fai riferimento a questo esempio per scoprire come utilizzare le tabelle INFORMATION_SCHEMA per copiare nomi delle colonne, tipi di dati e vincoli NOT NULL in una nuova tabella. |
CREATE TABLE table_name Nota: in Amazon Redshift, l'impostazione BACKUP
NO è specificata per risparmiare tempo di elaborazione e ridurre
lo spazio di archiviazione. |
L'opzione della tabella BACKUP NO non è utilizzata o necessaria perché BigQuery conserva automaticamente fino a 7 giorni delle versioni cronologiche di tutte le tabelle, senza influire sui tempi di elaborazione o sull'archiviazione fatturata.
|
CREATE TABLE table_name |
BigQuery supporta il clustering, che consente l'archiviazione delle chiavi in ordine. |
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 già esistente.
L'istruzione CREATE TABLE
di BigQuery supporta anche le seguenti clausole, che non hanno un equivalente di Amazon Redshift:
Per ulteriori informazioni su CREATE TABLE
in BigQuery, consulta gli esempi di CREATE TABLE
di BigQuery nella documentazione di DML.
Tabelle temporanee
Amazon Redshift supporta le tabelle temporanee, 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 breve durata (ad esempio, un'ora) in modo che le tabelle create nel set di dati siano effettivamente temporanee perché non durano più a lungo della durata del set di dati. Puoi anteporre il prefisso a tutti i nomi delle tabelle in questo set di dati per indicare chiaramente che le tabelle sono temporanee.
Tabella TTL: crea una tabella con una durata breve specifica per la tabella utilizzando istruzioni DDL simili alle seguenti:
CREATE TABLE temp.name (col1, col2, ...) OPTIONS (expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR));
Istruzione CREATE VIEW
La seguente tabella 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 di associazione tardiva per fare riferimento a una tabella esterna. |
In BigQuery, per creare una vista, tutti gli oggetti di riferimento devono già esistere. 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 relativo risultato come valore.
Sia Amazon Redshift che BigQuery supportano le funzioni definite dall'utente che utilizzano espressioni SQL. Inoltre, in Amazon Redshift puoi creare una funzione definita dall'utente basata su Python e in BigQuery una funzione definita dall'utente basata su JavaScript.
Fai riferimento al repository GitHub delle utilità di Google Cloud BigQuery per una libreria di funzioni definite dall'utente comuni di BigQuery.
Sintassi CREATE FUNCTION
La seguente tabella indica le differenze nella sintassi di creazione delle funzioni definite dall'utente SQL tra Amazon Redshift e BigQuery.
Amazon Redshift | BigQuery |
---|---|
CREATE [OR
REPLACE] FUNCTION |
CREATE [OR REPLACE] FUNCTION Nota: in una funzione definita dall'utente SQL di BigQuery, un tipo di dati restituito è facoltativo. BigQuery deduce 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à della funzione non è un parametro configurabile in BigQuery. Tutta la volatilità della funzione definita dall'utente di BigQuery è equivalente alla volatilità IMMUTABLE di Amazon Redshift, ovvero non esegue ricerche nel database o utilizza in altro modo informazioni non presenti direttamente nell'elenco di argomenti.
|
CREATE [OR
REPLACE] FUNCTION Nota: Amazon Redshift supporta solo una clausola SQL SELECT come definizione della funzione. Inoltre, la clausola SELECT non può includere nessuna delle 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, il riferimento a tabelle, viste o modelli non è supportato. |
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: non è necessario specificare il valore letterale della lingua in una funzione definita dall'utente GoogleSQL. BigQuery interpreta l'espressione SQL per impostazione predefinita. Inoltre, le citazioni in dollari di Amazon Redshift ( $$ ) non sono supportate in BigQuery. |
CREATE [OR
REPLACE] FUNCTION function_name (integer, integer) RETURNS
integer IMMUTABLE AS $$ SELECT $1 + $2 $$ LANGUAGE sql |
CREATE [OR REPLACE] FUNCTION Nota: le funzioni definite dall'utente BigQuery richiedono che tutti gli argomenti di input siano denominati. Le variabili di argomento Amazon Redshift ( $1 , $2 , ...) non sono supportate in BigQuery. |
CREATE [OR
REPLACE] FUNCTION Nota: Amazon Redshift non supporta ANY TYPE per le funzioni definite dall'utente SQL. Tuttavia, supporta l'utilizzo del tipo di dati ANYELEMENT nelle funzioni definite dall'utente basate su Python. |
CREATE [OR REPLACE] FUNCTION Nota: BigQuery supporta l'uso di ANY TYPE come tipo di argomento. La funzione accetta un input di qualsiasi tipo per questo argomento. Per ulteriori informazioni, consulta il parametro basato su modelli in BigQuery.
|
BigQuery supporta anche l'istruzione CREATE FUNCTION IF NOT EXISTS
, che considera la query riuscita e non intraprende alcuna azione se esiste già una funzione con lo stesso nome.
L'istruzione CREATE FUNCTION
di BigQuery supporta anche la creazione di funzioni
TEMPORARY
o TEMP
, che non hanno un equivalente Amazon Redshift.
Per i dettagli sull'esecuzione di una funzione definita dall'utente permanente di BigQuery, consulta la pagina relativa alle chiamate di funzioni definite dall'utente.
Sintassi DROP FUNCTION
La seguente tabella risolve le differenze nella sintassi DROP FUNCTION
tra
Amazon Redshift e BigQuery.
Amazon Redshift | BigQuery |
---|---|
DROP
FUNCTION |
DROP FUNCTION Nota: BigQuery non richiede l'utilizzo della firma della funzione per eliminarla. Inoltre, la rimozione delle dipendenze delle funzioni non è supportata in BigQuery. |
BigQuery supporta anche l'istruzione DROP FUNCTION IF EXISTS
, che elimina la funzione solo se esiste nel set di dati specificato.
BigQuery richiede di specificare il project_name se la funzione non si trova nel progetto attuale.
Componenti della funzione definita dall'utente
Questa sezione evidenzia le analogie e le differenze nei componenti delle funzioni definite dall'utente tra Amazon Redshift e BigQuery.
Componente | Amazon Redshift | BigQuery |
---|---|---|
Nome | Amazon Redshift consiglia di utilizzare il prefisso
_f per i nomi delle funzioni al fine di evitare conflitti con
i nomi delle funzioni SQL integrate esistenti o future. |
In BigQuery puoi utilizzare qualsiasi nome di funzione personalizzata. |
Argomenti | Gli argomenti sono facoltativi. Puoi utilizzare i tipi di nome e di dati per gli argomenti
della funzione definita dall'utente Python e solo i tipi di dati per gli argomenti della funzione SQL. Nelle funzioni SQL SQL, devi fare riferimento agli argomenti utilizzando $1 , $2 e così via. Inoltre, Amazon Redshift limita
il numero di argomenti a 32. |
Gli argomenti sono facoltativi, ma se li specifichi devono utilizzare sia il nome che i tipi di dati per le funzioni definite dall'utente JavaScript e SQL. Il numero massimo di argomenti per una funzione definita dall'utente permanente è 256. |
Tipo di dati | Amazon Redshift supporta un set di tipi di dati diverso per le funzioni definite dall'utente SQL e Python. Per una funzione definita dall'utente Python, il tipo di dati potrebbe anche essere ANYELEMENT .Devi specificare un RETURN tipo di dati per le funzioni definite dall'utente di SQL e Python.Consulta la sezione Tipi di dati in questo documento per conoscere gli equivalenti tra i tipi di dati in Amazon Redshift e in BigQuery. |
BigQuery supporta un set di tipi di dati diverso per le funzioni definite dall'utente SQL e JavaScript. Per una funzione SQL definita dall'utente, il tipo di dati potrebbe anche essere ANY TYPE . Per ulteriori informazioni, consulta i parametri basati su modelli in BigQuery.Il tipo di dati RETURN è facoltativo per le funzioni definite dall'utente SQL.Consulta Codifiche dei tipi SQL in JavaScript per informazioni su come i tipi di dati BigQuery vengono mappati ai tipi di dati JavaScript. |
Definizione | Per le funzioni definite dall'utente SQL e Python, devi racchiudere la definizione della funzione utilizzando le virgolette del dollaro, come in una coppia di simboli del dollaro ($$ ), per indicare l'inizio e la fine delle istruzioni delle funzioni.Per le UDF SQL,Amazon Redshift supporta solo una clausola SELECT 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 UDF di Python, puoi scrivere un programma Python utilizzando la libreria standard di Python 2.7 o importare moduli personalizzati creandone uno con il comando CREATE
LIBRARY . |
In BigQuery, devi racchiudere il codice JavaScript tra virgolette. Consulta la pagina relativa alle regole di citazione per ulteriori informazioni. Per le UDF SQL, puoi utilizzare qualsiasi espressione SQL come definizione della funzione. Tuttavia, BigQuery non supporta i riferimenti a tabelle, viste o modelli. Per le UDF JavaScript, puoi includere librerie di codici esterne direttamente utilizzando la OPTIONS sezione. Puoi inoltre utilizzare lo strumento di test della funzione definita dall'utente BigQuery per testare le tue funzioni. |
Lingua | Devi utilizzare LANGUAGE per specificare la lingua 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 js per le funzioni definite dall'utente JavaScript. |
Stato | Amazon Redshift non supporta la creazione di funzioni definite dall'utente temporanee. Amazon Redshift offre un'opzione per definire la volatilità di una funzione utilizzando VOLATILE , STABLE
o IMMUTABLE letterali. Viene utilizzato per l'ottimizzazione
dallo strumento di ottimizzazione delle query. |
BigQuery supporta le funzioni definite dall'utente permanenti e temporanee. Puoi riutilizzare
le funzioni definite dall'utente permanenti in più query, mentre puoi utilizzarle solo
in una singola query. La volatilità della funzione non è un parametro configurabile in BigQuery. L'intera volatilità delle funzioni definite dall'utente di BigQuery equivale alla IMMUTABLE
volatilità di Amazon Redshift. |
Sicurezza e privilegi | Per creare una funzione definita dall'utente, devi disporre dell'autorizzazione per l'utilizzo nel linguaggio per SQL o plpythonu (Python). Per impostazione predefinita, l'opzione USAGE ON LANGUAGE SQL è concessa a PUBLIC , ma devi concedere esplicitamente USAGE ON LANGUAGE PLPYTHONU
a utenti o gruppi specifici.Inoltre, per sostituire una funzione definita dall'utente devi essere un super user. |
In BigQuery non è necessario concedere autorizzazioni esplicite per la creazione o l'eliminazione di qualsiasi tipo di funzione definita dall'utente. Qualsiasi utente a cui viene assegnato un ruolo di Editor dati BigQuery (che ha 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 i limiti delle funzioni definite dall'utente di Python. | Consulta Limiti delle 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 le prestazioni delle query. Per ottenere informazioni sulla distribuzione dei dati, puoi utilizzare le funzioni aggregate approssimative. |
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, consulta Garanzie di coerenza. |
EXPLAIN
... |
Non utilizzato in BigQuery. Funzionalità simili sono la spiegazione del piano di query nella console Google Cloud di BigQuery e l'audit logging in Cloud Monitoring. |
SELECT * FROM SVV_TABLE_INFO WHERE |
SELECT * EXCEPT(is_typed) FROM Per saperne di più, consulta Introduzione a BigQuery INFORMATION_SCHEMA . |
VACUUM
[table_name] |
Non utilizzato in BigQuery. Le tabelle in cluster BigQuery vengono ordinate automaticamente. |
Istruzioni SQL a più istruzioni e multiriga
Sia Amazon Redshift che BigQuery supportano le transazioni (sessioni) e, di conseguenza, supportano istruzioni separate da punto e virgola che vengono eseguite insieme in modo coerente. Per maggiori informazioni, consulta Transazioni con più estratti conto.
Istruzioni SQL procedurali
Istruzione CREATE PROCEDURE
Amazon Redshift | BigQuery |
---|---|
CREATE or
REPLACE PROCEDURE |
CREATE PROCEDURE se è necessario
un nome.Altrimenti, utilizza l'opzione in linea con BEGIN o in una singola riga con CREATE TEMP FUNCTION . |
CALL |
CALL |
Dichiarazione e assegnazione delle 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 oppure imposta più variabili contemporaneamente in base al risultato di più espressioni. |
Gestori delle condizioni di errore
In Amazon Redshift, un errore riscontrato durante l'esecuzione di una stored procedure termina il flusso di esecuzione, termina la transazione e ne esegue il rollback.
Questi risultati si verificano perché le transazioni secondarie non sono supportate. In una procedura archiviata di Amazon Redshift, l'unico handler_statement
supportato è RAISE
. In BigQuery, la gestione degli errori è una funzionalità principale del flusso di controllo principale, simile a quella offerta da altre lingue 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 i cursori o le 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 set di risultati, puoi ottenere un comportamento simile utilizzando le tabelle temporanee in BigQuery.
Istruzioni SQL dinamiche
La funzionalità di script in BigQuery supporta le istruzioni SQL dinamiche come quelle mostrate nella seguente tabella.
Amazon Redshift | BigQuery |
---|---|
EXECUTE |
EXECUTE IMMEDIATE |
Istruzioni flusso di controllo
Amazon Redshift | BigQuery |
---|---|
IF..THEN..ELSIF..THEN..ELSE..END
IF |
IF condition |
name CURSOR
[ ( arguments ) ] FOR query |
In BigQuery non vengono utilizzati i cursori o le sessioni. |
[< |
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 agli ACID a livello di singola mutazione su molte righe.
Transazioni
Per impostazione predefinita, Amazon Redshift supporta l'isolamento seriale per le transazioni. Amazon Redshift ti consente di specificare uno dei quattro livelli di isolamento delle transazioni standard SQL, ma elabora tutti i livelli di isolamento come serializzabili.
BigQuery inoltre supporta le transazioni. BigQuery aiuta a garantire il controllo ottimistico della contemporaneità (il primo a eseguire il commit ha la priorità) mediante l'isolamento snapshot, in cui una query legge gli ultimi dati di cui è stato eseguito il commit prima dell'avvio. Questo approccio garantisce lo stesso livello di coerenza su base per riga, per mutazione e tra le righe all'interno della stessa istruzione DML, evitando però i deadlock. In caso di più aggiornamenti DML sulla stessa tabella, BigQuery passa al controllo della contemporaneità pessimistica. I job di caricamento possono essere eseguiti in modo completamente indipendente e aggiunti alle tabelle.
Esegui il rollback
Se Amazon Redshift riscontra un errore durante l'esecuzione di una stored procedure, esegue il rollback di tutte le modifiche apportate in una transazione. Inoltre, puoi utilizzare l'istruzione di controllo delle transazioni ROLLBACK
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. Contattando il team di assistenza Cloud per aumentare le quote per utenti con volumi elevati, La seguente tabella mostra un confronto dei limiti dei database di Amazon Redshift e BigQuery.
Limite | Amazon Redshift | BigQuery |
---|---|---|
Tabelle in ogni database per i tipi di nodi cluster di grandi dimensioni e xlarge | 9900 | Senza restrizioni |
Tabelle in ogni database per tipi di nodi cluster di dimensioni 8xlarge | 20.000 | Senza restrizioni |
Database definiti dall'utente che puoi creare per ogni cluster | 60 | Senza restrizioni |
Dimensione massima della riga | 4 MB | 100 MB |