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 le funzionalità di traduzione SQL batch in eseguire la migrazione collettiva degli script SQL traduzione SQL interattiva per tradurre query ad hoc.
I destinatari di questa guida sono Enterprise Architect, database amministratori, sviluppatori di applicazioni ed esperti della sicurezza IT. it 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 | Note | |
---|---|---|---|
Tipo di dati | Alias | Tipo di dati | |
SMALLINT |
INT2 |
INT64 |
Il valore SMALLINT di Amazon Redshift è di 2 byte, mentre il valore di BigQuery
INT64 è di 8 byte. |
INTEGER |
INT64 |
Il valore INTEGER di Amazon Redshift è di 4 byte, mentre BigQuery INTEGER
INT64 è di 8 byte. |
|
BIGINT |
INT8 |
INT64 |
Sia BIGINT che BigQuery
INT64 sono 8 byte. |
DECIMAL |
NUMERIC |
NUMERIC |
|
REAL |
FLOAT4 |
FLOAT64 |
Il valore REAL di Amazon Redshift è di 4 byte, mentre BigQuery REAL
FLOAT64 è 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. di BigQuery
Il tipo di dati BOOL non fa distinzione tra maiuscole e minuscole
TRUE . |
CHAR |
STRING |
||
VARCHAR |
STRING |
||
DATE |
DATE |
||
TIMESTAMP |
TIMESTAMP WITHOUT TIME ZONE |
DATETIME |
|
TIMESTAMPTZ |
TIMESTAMP |
Nota: in BigQuery vengono utilizzati i fusi orari durante l'analisi timestamp o la formattazione di timestamp per la visualizzazione. Un formato stringa potrebbe includere un fuso orario, ma quando BigQuery analizza memorizza il timestamp nell'ora UTC equivalente. Quando il fuso orario non è specificato esplicitamente, il fuso orario predefinito, UTC, è in uso. Fuso orario nomi utente o offset da UTC utilizzando (-|+)HH:MM sono supportate, ma le abbreviazioni dei fusi orari, come PDT, supportati. | |
GEOMETRY |
GEOGRAPHY |
Supporto per l'esecuzione di query su dati geospaziali. |
BigQuery include anche i seguenti tipi di dati che non hanno un'istanza diretta Amazon Redshift analogico:
Tipi di conversione impliciti
Quando esegui la migrazione a BigQuery, devi convertire la maggior parte Conversioni implicite di Amazon Redshift alle conversioni esplicite di BigQuery, ad eccezione dei seguenti tipi di dati, che BigQuery converte in modo implicito.
BigQuery esegue conversioni implicite per i seguenti tipi di dati:
Dal tipo BigQuery | Come digitare BigQuery |
---|---|
|
|
|
|
|
|
BigQuery esegue anche conversioni implicite per i seguenti valori letterali:
Dal tipo BigQuery | Come digitare BigQuery |
---|---|
STRING letterale (ad es. "2008-12-25") |
|
STRING letterale (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 lo strumento
Funzione CAST(expression AS type)
o uno qualsiasi dei
DATE
e
TIMESTAMP
le funzioni di conversione.
Durante la migrazione delle query, modifica qualsiasi occorrenza di Amazon Redshift
CONVERT(type, expression)
(o la sintassi ::) a BigQuery
nella funzione CAST(expression AS type)
,
come mostrato nella tabella nella sezione Funzioni di formattazione del tipo di dati.
Sintassi delle query
Questa sezione illustra le differenze di sintassi delle query tra Amazon Redshift e in BigQuery.
Istruzione SELECT
La maggior parte di Amazon Redshift
SELECT
sono compatibili con BigQuery. La seguente tabella contiene un elenco
differenze minime.
Amazon Redshift | BigQuery |
---|---|
|
|
|
|
BigQuery supporta anche le seguenti espressioni nelle istruzioni SELECT
, che
non hanno un equivalente Amazon Redshift:
Clausola FROM
R
FROM
in una query elenca i riferimenti tabella da cui vengono selezionati i dati. Nella
Amazon Redshift, i possibili riferimenti alle tabelle includono tabelle, viste e sottoquery. Tutti
di questi riferimenti alle tabelle sono supportati in BigQuery.
È possibile fare riferimento alle tabelle BigQuery nel FROM
utilizzando quanto segue:
[project_id].[dataset_id].[table_name]
[dataset_id].[table_name]
[table_name]
BigQuery supporta anche ulteriori riferimenti alle tabelle:
- Le versioni storiche della definizione della tabella e delle righe utilizzando
FOR SYSTEM_TIME AS OF
- Percorsi dei campi,
o qualsiasi percorso che si risolva in un campo all'interno di un tipo di dati (ad esempio un
STRUCT
). - Matrici appiattite.
JOIN
tipi
Amazon Redshift e BigQuery supportano i seguenti tipi di join:
[INNER] JOIN
LEFT [OUTER] JOIN
RIGHT [OUTER] JOIN
FULL [OUTER] JOIN
CROSS JOIN
e equivalente incrocio incrociato implicito con virgole.
La seguente tabella contiene un elenco di differenze di minore entità.
Amazon Redshift | BigQuery |
---|---|
|
Nota: in BigQuery, le clausole JOIN richiedono una
Condizione JOIN a meno che la clausola non sia una CROSS
JOIN o una delle tabelle unite non sia un campo in un tipo di dati
o un array. |
Clausola WITH
Un modello BigQuery
WITH
contiene una o più sottoquery denominate che vengono eseguite quando una
L'istruzione SELECT
li fa riferimento. Amazon Redshift
WITH
si comportano allo stesso modo di BigQuery con l'eccezione che puoi valutare
una sola volta la clausola e riutilizzarne i risultati.
Operatori Set
Esistono alcune piccole differenze tra Operatori dei set Amazon Redshift e Set BigQuery operatori. Tuttavia, tutte le operazioni 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 set diversi operazioni. Se si ripete lo stesso operatore impostato, le parentesi non vengono necessaria. |
Clausola ORDER BY
Ci sono alcune piccole differenze tra Amazon Redshift
ORDER BY
e BigQuery
ORDER BY
le clausole del deployment.
Amazon Redshift | BigQuery |
---|---|
In Amazon Redshift, i NULL sono classificati per impostazione predefinita (ordine crescente
dell'ordine). |
In BigQuery, per impostazione predefinita, le NULL vengono classificate per prime
(ordine crescente). |
|
Nota: BigQuery non utilizza la sintassi LIMIT ALL , ma
Per impostazione predefinita, ORDER BY ordina tutte le righe, ottenendo
comporta lo stesso comportamento della clausola LIMIT ALL di Amazon Redshift. Abbiamo moltissimo
consiglia di includere una clausola LIMIT con ogni
Clausola ORDER BY . Ordinamento di tutte le righe di risultati inutilmente
ne peggiora le prestazioni di esecuzione. |
|
Nota: in BigQuery, OFFSET deve essere utilizzato insieme a
LIMIT conteggio. Assicurati di impostare count.
INT64 al numero minimo di righe ordinate necessarie.
Ordine di tutte le righe dei risultati riduce inutilmente le prestazioni di esecuzione delle query. |
Condizioni
La tabella seguente mostra le condizioni Amazon Redshift, o predicati, che sono specifici di Amazon Redshift e devono essere convertiti Equivalente BigQuery.
Amazon Redshift | BigQuery |
---|---|
|
|
|
|
|
|
|
Nota: BigQuery non supporta i caratteri di escape personalizzati. Devi utilizzare due barre rovesciate \\ come caratteri di escape per BigQuery. |
|
Nota: se NOT è specificato, aggrega quanto riportato sopra
Espressione IF in un'espressione NOT come mostrato
sotto:
|
|
|
Funzioni
Le seguenti sezioni elencano le funzioni Amazon Redshift e i loro equivalenti BigQuery.
Funzioni di aggregazione
La tabella seguente mostra le mappature tra i dati aggregati di Amazon Redshift e i dati aggregati funzioni analitiche e di aggregazione approssimate con gli equivalenti BigQuery.
Amazon Redshift | BigQuery |
---|---|
APPROXIMATE
COUNT(DISTINCT expression) |
APPROX_COUNT_DISTINCT(expression) |
APPROXIMATE
PERCENTILE_DISC( |
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( e Nota: non copre i casi d'uso relativi all'aggregazione. |
STDDEV([DISTINCT] expression) |
STDDEV([DISTINCT] expression) |
STDDEV_SAMP([DISTINCT] expression) |
STDDEV_SAMP([DISTINCT] expression) |
STDDEV_POP([DISTINCT] expression) |
STDDEV_POP([DISTINCT] expression) |
SUM([DISTINCT] expression) |
SUM([DISTINCT] expression) |
VARIANCE([DISTINCT] expression) |
VARIANCE([DISTINCT] expression) |
VAR_SAMP([DISTINCT] expression) |
VAR_SAMP([DISTINCT] expression) |
VAR_POP([DISTINCT] expression) |
VAR_POP([DISTINCT] expression) |
BigQuery offre anche le seguenti opzioni aggregate, analisi aggregate, e aggregata 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 aggregate a livello di bit
La tabella seguente mostra le mappature tra l'aggregazione bit a bit di Amazon Redshift comune con i rispettivi equivalenti BigQuery.
Amazon Redshift | BigQuery |
---|---|
BIT_AND(expression) |
BIT_ADD(expression) |
BIT_OR(expression) |
BIT_OR(expression) |
BOOL_AND>(expression) |
LOGICAL_AND(expression) |
BOOL_OR(expression) |
LOGICAL_OR(expression) |
BigQuery offre anche le seguenti opzioni aggregata a bit , che non ha un analogo diretto in Amazon Redshift:
Funzioni finestra
La tabella seguente mostra le mappature tra le funzioni finestra di Amazon Redshift comuni con gli equivalenti BigQuery. Le funzioni 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 tabella seguente mostra le mappature tra le comuni condizionali di Amazon Redshift con i rispettivi 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 inoltre le seguenti espressioni condizionali, che non hanno un analogico diretto in Amazon Redshift:
Funzioni di data e ora
La tabella seguente mostra le mappature tra data e ora di Amazon Redshift comuni con i rispettivi equivalenti BigQuery. Funzioni di dati e ora di BigQuery includi funzioni di data, dataora funzioni, funzioni temporali, e funzioni timestamp.
Tieni presente che le funzioni che sembrano identiche in Amazon Redshift e BigQuery restituiscono diversi tipi di dati.
Amazon Redshift | BigQuery |
---|---|
ADD_MONTHS( |
CAST( DATE_ADD( |
timestamptz_or_timestamp AT TIME
ZONE timezone |
PARSE_TIMESTAMP( Nota: durante l'analisi vengono utilizzati i fusi orari timestamp o la formattazione di timestamp per la visualizzazione. Un formato stringa potrebbe includere un fuso orario, ma quando BigQuery analizza memorizza il timestamp nell'ora UTC equivalente. Quando il fuso orario non è specificato esplicitamente, il fuso orario predefinito, UTC, è in uso. I nomi dei fusi orari o l'offset rispetto al fuso orario UTC (-HH:MM) sono supportato, ma le abbreviazioni dei fusi orari (ad esempio PDT) non sono supportate supportati. |
CONVERT_TIMEZONE( |
PARSE_TIMESTAMP( Nota: in BigQuery il fuso orario di source_timezone è UTC. |
CURRENT_DATE Nota: restituisce la data di inizio della transazione corrente nell'account fuso orario della sessione (UTC per impostazione predefinita). |
CURRENT_DATE() e Nota: restituisce la data di inizio dell'istruzione corrente nel fuso orario UTC zona di destinazione. |
DATE_CMP(date1, date2)
|
CASE |
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 le seguenti opzioni
per analizzare un intervallo Redshift e
in secondi. CREATE TEMP FUNCTION Per confrontare i valori letterali degli intervalli, 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 nell'attributo fuso orario della sessione attuale (UTC per impostazione predefinita). |
CURRENT_TIMESTAMP() Nota: restituisce il timestamp di inizio per l'istruzione corrente nel fuso orario UTC zona di destinazione. |
TIMEOFDAY() |
FORMAT_TIMESTAMP( |
TIMESTAMP_CMP( |
CASE |
TIMESTAMP_CMP_DATE( |
CASE |
TIMESTAMP_CMP_TIMESTAMPTZ(
Nota: Redshift confronta i timestamp relativi al tempo definito dalla sessione utente zona di destinazione. 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 relativi al tempo definito dalla sessione utente zona di destinazione. 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 relativi al tempo definito dalla sessione utente zona di destinazione. 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 relativi al tempo definito dalla sessione utente zona di destinazione. Il fuso orario predefinito della sessione utente è UTC. |
CASE Nota: BigQuery confronta i timestamp nel fuso orario UTC. |
TIMEZONE( |
PARSE_TIMESTAMP( Nota: durante l'analisi vengono utilizzati i fusi orari timestamp o la formattazione di timestamp per la visualizzazione. Un formato stringa potrebbe includere un fuso orario, ma quando BigQuery analizza memorizza il timestamp nell'ora UTC equivalente. Quando il fuso orario non è specificato esplicitamente, il fuso orario predefinito, UTC, è in uso. I nomi dei fusi orari o l'offset rispetto al fuso orario UTC (-HH:MM) sono supportato, ma le abbreviazioni del fuso orario (ad esempio PDT) non sono supportate supportati. |
TO_TIMESTAMP(timestamp,
format) |
PARSE_TIMESTAMP( Nota: BigQuery segue un insieme diverso di elementi di formato. I fusi orari vengono utilizzati durante l'analisi timestamp o la formattazione di timestamp per la visualizzazione. Un formato stringa potrebbe includere un fuso orario, ma quando BigQuery analizza memorizza il timestamp nell'ora UTC equivalente. Quando il fuso orario non è specificato esplicitamente, il fuso orario predefinito, UTC, è in uso. I nomi dei fusi orari o l'offset rispetto al fuso orario UTC (-HH:MM) sono supportato nella stringa del formato, ma le abbreviazioni del fuso orario (come PDT) non sono supportate. |
TRUNC(timestamp) |
CAST(timestamp AS
DATE) |
BigQuery offre anche le seguenti funzioni di data e ora, che non dispongono di un analogico diretto in Amazon Redshift:
EXTRACT
DATE
DATE_SUB
DATE_ADD
(ritornoDATE
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 i comuni matematici Amazon Redshift con i rispettivi equivalenti BigQuery.
Amazon Redshift | BigQuery |
---|---|
|
|
|
|
|
|
Nota: se l'operatore è eseguire la divisione di numeri interi (in altre parole, se X e
Y sono entrambi
numeri interi), viene restituito un numero intero. Se l'operatore esegue
divisione non intero, viene restituito un numero non intero. |
Se la divisione del numero intero: CAST(FLOOR(X / Y) AS INT64)
Se non è una divisione intera:
Nota: la divisione in BigQuery restituisce un numero non intero. Per evitare errori da un'operazione di divisione (errore di divisione per zero), usa SAFE_DIVIDE(X, Y) o
IEEE_DIVIDE(X, Y) . |
|
Nota: per evitare errori da un'operazione di divisione (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 (valore negativo ), utilizza SAFE.SQRT(X) . Input negativo
con SAFE.SQRT(X) risultati in
NULL . |
|
Nota: POWER(X, Y) di BigQuery restituisce un
errore se X è un valore finito inferiore a 0
e Y è un numero non intero. |
|
|
|
Nota: questo operatore restituisce 0 o una sequenza di byte di b'\x00' se le il secondo operando Y è maggiore o uguale alla lunghezza in bit della
primo operando X (ad esempio, 64 se X è di tipo INT64). Questo
l'operatore genera un errore se Y è negativo. |
|
Nota: sposta il primo operando X verso destra. Questo operatore non
eseguire l'estensione bit di segno con un tipo firmato (riempie i bit vuoti sulla
lasciato con 0). Questo operatore restituisce 0 o una sequenza di byte di B"\x00" se il secondo operando Y è maggiore o uguale al bit
lunghezza 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 ha una analogico diretto in Amazon Redshift:
X ^ Y
(bitwise xor)
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 concatenando un numero qualsiasi di stringhe. |
CRC32 |
Funzione personalizzata definita dall'utente |
FUNC_SHA1(string) |
SHA1(string) |
INITCAP |
INITCAP |
LEFT(string, integer) |
SUBSTR(string, 0, integer)
|
RIGHT(string, integer)
|
SUBSTR(string,
-integer) |
LEN(expression) |
LENGTH(expression) |
LENGTH(expression) |
LENGTH(expression) |
LOWER(string) |
LOWER(string) |
LPAD(string1, length[,
string2]) |
LPAD(string1, length[,
string2]) |
RPAD(string1, length[,
string2]) |
RPAD(string1, length[,
string2]) |
LTRIM(string,
trim_chars) |
LTRIM(string,
trim_chars) |
MD5(string) |
MD5(string) |
OCTET_LENGTH(expression) |
BYTE_LENGTH(expression) |
POSITION(substring IN
string) |
STRPOS(string,
substring) |
QUOTE_IDENT(string) |
CONCAT('"',string,'"') |
QUOTE_LITERAL(string) |
CONCAT("'",string,"'")
|
REGEXP_COUNT(
source_string, pattern |
ARRAY_LENGTH( REGEXP_EXTRACT_ALL( Se position è specificato: ARRAY_LENGTH( REGEXP_EXTRACT_ALL( Nota: BigQuery fornisce il supporto per le espressioni regolari utilizzando la libreria re2 ; vedi che
documentazione per 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 l'espressione regolare assistenza utilizzando il re2
biblioteca; scopri che documentazione per la sua espressione regolare a riga di comando. |
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 fornisce il supporto per le espressioni regolari utilizzando la libreria re2 ; vedi che
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 implementata 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 stringa 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 in cui stringa per date_string . |
TO_NUMBER(string, format) |
CAST( Nota: BigQuery e Amazon Redshift differiscono nel modo in cui 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. della
un esempio,
SAFE_CAST
("apple"
AS INT64)
restituisce NULL
.
Sintassi DML
Questa sezione illustra le differenze nella sintassi del linguaggio di gestione dei dati Amazon Redshift e BigQuery.
Istruzione INSERT
Amazon Redshift offre una parola chiave DEFAULT
configurabile per le colonne. Nella
BigQuery, il valore DEFAULT
per le colonne con valori nulli è NULL
,
e DEFAULT
non è supportato per
colonne obbligatorie. Più alta
Istruzioni INSERT
Amazon Redshift
sono compatibili 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 vengono calcolati utilizzando una sottoquery), che non è supportata in Amazon Redshift. Per esempio:
INSERT INTO table (column1, column2)
VALUES ('value_1', (
SELECT column2
FROM table2
))
Istruzione COPY
Amazon Redshift
Comando COPY
carica i dati in una tabella da file di dati o da una tabella Amazon DynamoDB.
BigQuery non utilizza il comando SQL COPY
per caricare i dati,
ma puoi utilizzare uno qualsiasi dei vari strumenti e opzioni non SQL
caricare dati in tabelle BigQuery.
Puoi anche utilizzare i sink di pipeline di dati forniti
Apache Spark
o
Apache Beam
per scrivere dati in BigQuery.
Istruzione UPDATE
La maggior parte delle istruzioni UPDATE
di Amazon Redshift è compatibile con BigQuery. Le seguenti
mostra le eccezioni.
Amazon Redshift | BigQuery |
---|---|
UPDATE table |
UPDATE table Nota: tutte le istruzioni UPDATE in BigQuery richiedono una parola chiave WHERE ,
seguito 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 , il valore
L'istruzione UPDATE di BigQuery deve essere condizionata da WHERE TRUE . |
Estratti conto DELETE
e TRUNCATE
Le istruzioni DELETE
e TRUNCATE
consentono di rimuovere righe da una tabella in entrambi i modi
senza influire sullo schema o sugli indici della tabella.
In Amazon Redshift, l'istruzione TRUNCATE
è consigliata rispetto a una
DELETE
non qualificata perché
più velocemente e non richiede successivamente VACUUM
e ANALYZE
operazioni.
Tuttavia, puoi utilizzare le istruzioni DELETE
per ottenere lo stesso effetto.
In BigQuery, l'istruzione DELETE
deve avere una clausola WHERE
. Per maggiori informazioni
informazioni su DELETE
in BigQuery, consulta
BigQuery
DELETE
esempi
nella documentazione di DML.
Amazon Redshift | BigQuery |
---|---|
DELETE
[FROM] table_name TRUNCATE
[TABLE] table_name |
DELETE FROM table_name Le istruzioni DELETE di BigQuery richiedono
Clausola WHERE . |
DELETE FROM table_name |
DELETE FROM table_name DELETE FROM table_name In Amazon Redshift, USING consente tabelle aggiuntive
a cui si fa riferimento nel
WHERE . Questo può essere ottenuto in
BigQuery utilizzando una sottoquery in
la clausola WHERE . |
Istruzione MERGE
L'istruzione MERGE
può combinare INSERT
, UPDATE
,
e DELETE
in un
un'unica istruzione upsert ed eseguire le operazioni a livello atomico. MERGE
deve corrispondere al massimo a una riga di origine per ogni riga target.
Amazon Redshift non supporta un solo comando MERGE
. Tuttavia, un
operazione di unione
che può essere eseguita in Amazon Redshift
Operazioni di INSERT
, UPDATE
e DELETE
in una transazione.
Operazione di unione sostituendo righe esistenti
In Amazon Redshift, è possibile eseguire una sovrascrittura di tutte le colonne nella tabella di destinazione
eseguita utilizzando un'istruzione DELETE
e poi un'istruzione INSERT
. DELETE
rimuove le righe che devono essere aggiornate, mentre l'istruzione INSERT
inserisce le righe aggiornate. Le tabelle BigQuery sono limitate a
1000 istruzioni DML
al giorno, quindi devi consolidare INSERT
, UPDATE
e DELETE
in una
singola istruzione MERGE
, come illustrato nella seguente tabella.
Amazon Redshift | BigQuery |
---|---|
Consulta la sezione Esecuzione di un
l'operazione di unione sostituendo
righe esistenti. CREATE TEMP TABLE temp_table; |
MERGE target Nota: se aggiorni tutte le colonne, devono essere elencate tutte le colonne. |
Consulta la sezione Esecuzione di un
di unione specificando un
dell'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 un
eseguire una query in una nuova tabella, combinando creazione e 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. Consulta le tabelle temporanee per ulteriori informazioni. |
Istruzione CREATE TABLE
La maggior parte di Amazon Redshift
CREATE TABLE
sono compatibili 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
applicata dal sistema di Amazon Redshift. |
CREATE TABLE table_name ( |
CREATE TABLE table_name Nota: i vincoli UNIQUE e PRIMARY KEY sono informativi e non sono
applicata dal sistema Amazon Redshift.
|
CREATE TABLE table_name Nota: BigQuery non utilizza le tabelle UNIQUE , PRIMARY KEY o FOREIGN KEY
i vincoli. Per ottenere un'ottimizzazione simile fornita da questi vincoli durante l'esecuzione delle query,
partizionare e raggruppare le tabelle BigQuery. CLUSTER BY supporta fino a
4 colonne. |
CREATE TABLE table_name |
Fai riferimento a questo esempio per scoprire come utilizzare
le tabelle INFORMATION_SCHEMA per copiare i nomi delle colonne, i tipi di dati
NOT NULL vincolati a una nuova tabella. |
CREATE TABLE table_name Nota: in Amazon Redshift, l'impostazione BACKUP
NO è specificata per risparmiare tempo di elaborazione e ridurre
di archiviazione. |
L'opzione della tabella BACKUP NO non è utilizzata o necessaria perché BigQuery
conserva automaticamente per 7 giorni le versioni storiche di tutti
le tabelle senza alcun effetto sul tempo di elaborazione o sull'archiviazione fatturata.
|
CREATE TABLE table_name |
BigQuery supporta il clustering, che consente di archiviare le 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 esiste già.
L'istruzione CREATE TABLE
di BigQuery supporta anche le seguenti clausole, che:
non hanno un equivalente Amazon Redshift:
Per saperne di più su CREATE TABLE
in BigQuery, consulta
BigQuery
CREATE TABLE
esempi
nella documentazione di DML.
Tabelle temporanee
Amazon Redshift supporta le tabelle temporanee, che sono visibili solo all'interno dello stato attuale durante la sessione. Esistono diversi modi per emulare tabelle temporanee in BigQuery:
- TTL del set di dati: crea un set di dati di breve durata (ad ad esempio, un'ora) in modo che tutte le tabelle create nel set di dati sono temporanei poiché non si mantengono più a lungo rispetto ai set di dati durata. Puoi aggiungere il prefisso a tutti i nomi delle tabelle in questo set di dati con per indicare chiaramente che le tabelle sono temporanee.
TTL tabella: crea una tabella con una breve durata 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 tabella seguente mostra gli equivalenti tra Amazon Redshift e BigQuery per il
CREATE VIEW
.
Amazon Redshift | BigQuery |
---|---|
CREATE VIEW view_name AS SELECT ... code> |
CREATE VIEW view_name AS SELECT
... |
CREATE OR REPLACE VIEW view_name AS SELECT ... |
CREATE OR REPLACE VIEW |
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 associazione tardiva per fare riferimento a un in una tabella esterna. |
In BigQuery, per creare una vista, tutti gli oggetti di riferimento devono già
esistono. BigQuery ti consente di eseguire query su origini dati esterne. |
Funzioni definite dall'utente
Una funzione definita dall'utente consente di creare funzioni per le operazioni personalizzate. Queste funzioni accettano colonne di input, eseguire azioni e restituire il risultato di queste azioni come valore.
Sia Amazon Redshift che BigQuery supportano le funzioni definite dall'utente che utilizzano espressioni SQL. Inoltre, Amazon Redshift, puoi creare UDF basata su Python, e in BigQuery puoi creare UDF basata su JavaScript.
Consulta le 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 illustra le differenze nella sintassi di creazione delle funzioni SQL definite dall'utente tra Amazon Redshift e BigQuery.
Amazon Redshift | BigQuery |
---|---|
CREATE [OR
REPLACE] FUNCTION |
CREATE [OR REPLACE] FUNCTION Nota: in una UDF SQL di BigQuery, un tipo di dati restituiti è facoltativo. BigQuery deduce il tipo di risultato della funzione dal Corpo della funzione SQL quando una query chiama la funzione. |
CREATE [OR
REPLACE] FUNCTION |
CREATE [OR REPLACE] FUNCTION Nota: la volatilità della funzione non è un parametro configurabile in in BigQuery. Tutta la volatilità delle funzioni definite dall'utente di BigQuery è equivalente a quella di Amazon Redshift Volatilità di IMMUTABLE (ovvero, non esegue ricerche nel database o
altrimenti userà informazioni non presenti direttamente nel suo elenco di argomenti).
|
CREATE [OR
REPLACE] FUNCTION Nota: Amazon Redshift supporta solo una clausola SQL SELECT come funzione
definizione di Kubernetes. Inoltre, la clausola SELECT non può includere nessuna delle clausole FROM,
INTO, WHERE, GROUP BY, ORDER BY, e LIMIT . |
CREATE [OR REPLACE] FUNCTION Nota: BigQuery supporta qualsiasi espressione SQL come definizione delle funzioni. Tuttavia, non è supportato fare riferimento a tabelle, viste o modelli. |
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 funzione definita dall'utente di GoogleSQL. BigQuery interpreta l'espressione SQL per impostazione predefinita. Inoltre, Amazon Redshift citazione in dollari ( $$ ) is not supported in BigQuery. |
CREATE [OR
REPLACE] FUNCTION function_name (integer, integer) RETURNS
integer IMMUTABLE AS $$ SELECT $1 + $2 $$ LANGUAGE sql |
CREATE [OR REPLACE] FUNCTION 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 SQL type encodings in JavaScript for information on how BigQuery data types map to JavaScript data types. |
Definition | For both SQL and Python UDFs, you must enclose the function
definition using dollar quoting, as in a pair of dollar signs
($$ ), per indicare l'inizio e la fine della funzione
istruzioni.Per SQL funzioni definite dall'utente, Amazon Redshift supporta solo una SELECT clausola SQL
come definizione della funzione. Inoltre, la clausola SELECT
non può includere FROM , INTO ,
WHERE GROUP BY , ORDER BY e LIMIT
.Per Python UDF, puoi scrivere un programma Python utilizzando lo standard Python 2.7 Libreria o importa i moduli personalizzati creandone uno utilizzando CREATE
LIBRARY . |
In BigQuery, devi racchiudere il codice JavaScript tra virgolette. Consulta
Citazione di regole per ulteriori informazioni
informazioni. Per le UDF SQL, puoi utilizzare qualsiasi come definizione della funzione. Tuttavia, BigQuery non supportano i riferimenti a tabelle, viste o modelli. Per le UDF JavaScript, puoi includere librerie di codice esterne direttamente usando la sezione OPTIONS . Puoi anche utilizzare la funzione definita dall'utente di BigQuery
di test per testare le tue funzioni. |
Lingua | Devi usare il valore letterale LANGUAGE per specificare
come sql per le funzioni definite dall'utente di SQL o plpythonu
per le funzioni definite dall'utente in Python. |
Non devi specificare LANGUAGE per le funzioni SQL definite dall'utente, ma devi
specificare la lingua js per le funzioni JavaScript definite dall'utente. |
Stato | Amazon Redshift non supporta la creazione di funzioni 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
lo strumento di ottimizzazione delle query. |
BigQuery supporta le funzioni definite dall'utente sia permanenti sia temporanee. Puoi riutilizzare
funzioni definite dall'utente permanenti per più query, mentre è possibile usare solo
funzioni definite dall'utente temporanee in una singola query. La volatilità della funzione non è un parametro configurabile in BigQuery. Tutti La volatilità della funzione definita dall'utente di BigQuery è equivalente alla volatilità IMMUTABLE
di Amazon Redshift. |
Sicurezza e privilegi | Per creare una funzione definita dall'utente, devi disporre dell'autorizzazione
per l'utilizzo sul linguaggio per SQL o plpythonu (Python). Per impostazione predefinita,
USAGE ON LANGUAGE SQL è stato concesso a PUBLIC ,
ma devi concedere esplicitamente USAGE ON LANGUAGE PLPYTHONU
a utenti o gruppi specifici.Inoltre, devi essere un super user per sostituire una funzione definita dall'utente. |
Concessione di autorizzazioni esplicite per la creazione o l'eliminazione di qualsiasi tipo di
La funzione definita dall'utente non è necessaria in BigQuery. Qualsiasi utente a cui è stato assegnato un ruolo di 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 opzione può essere gestita utilizzando Cloud IAM. |
Limiti | Vedi la UDF di Python limiti. | 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 ordinare per migliorare le prestazioni delle query. Per ottenere informazioni sui tuoi dati automatica, puoi utilizzare 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 la sezione Coerenza garantiti. |
EXPLAIN
... |
Non utilizzato in BigQuery. Funzionalità simili sono la spiegazione del piano di query nella console Google Cloud di BigQuery e nell'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 vengono ordinate automaticamente di BigQuery. |
Istruzioni SQL a più istruzioni e multiriga
Amazon Redshift e BigQuery supportano le transazioni (sessioni) e, di conseguenza, supportano istruzioni separate da punti e virgola che sono in modo coerente eseguite insieme. Per ulteriori informazioni, vedi Transazioni multi-istruzione.
Istruzioni SQL procedurali
Istruzione CREATE PROCEDURE
Amazon Redshift | BigQuery |
---|---|
CREATE or
REPLACE PROCEDURE |
CREATE PROCEDURE se il nome è
obbligatorio.Altrimenti, usalo in linea con BEGIN o in una singola riga con CREATE TEMP FUNCTION . |
CALL |
CALL |
Dichiarazione di variabili e assegnazione
Amazon Redshift | BigQuery |
---|---|
DECLARE |
DECLARE Dichiara una variabile del tipo specificato. |
SET |
SET Imposta una variabile in modo che abbia il valore dell'espressione o degli insiemi forniti più variabili contemporaneamente, in base al risultato di le espressioni regolari. |
Gestori delle condizioni degli errori
In Amazon Redshift si è verificato un errore durante l'esecuzione di una stored procedure
termina il flusso di esecuzione, termina la transazione ed esegue il rollback della transazione.
Questi risultati si verificano perché le transazioni secondarie non sono supportate. In un
Procedura archiviata da Amazon Redshift, l'unica handler_statement
supportata
è RAISE
. In BigQuery, si verifica un errore
è una caratteristica fondamentale del flusso di controllo principale, in modo simile
lingue offrono blocchi di 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 sono utilizzati 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 risultati simili il comportamento degli utenti tabelle temporanee in BigQuery.
Istruzioni SQL dinamiche
La funzionalità di scripting in BigQuery supporta istruzioni SQL dinamiche come quelle mostrate di seguito tabella.
Amazon Redshift | BigQuery |
---|---|
EXECUTE |
EXECUTE IMMEDIATE |
Istruzioni Flow-of-control
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
Amazon Redshift e BigQuery sono entrambi atomici, ovvero compatibili con ACID per singola mutazione livello su più righe.
Transazioni
Amazon Redshift supporta isolamento serializzabile per impostazione predefinita per le transazioni. Amazon Redshift ti consente specifica uno dei quattro livelli di isolamento delle transazioni standard SQL, ma elabora tutti di isolamento come serializzabili.
BigQuery inoltre supporta le transazioni. BigQuery aiuta a garantire controllo ottimistico della contemporaneità (il primo commit ha la priorità) con istantanea isolamento, in cui una query legge gli ultimi dati di cui è stato eseguito il commit prima dell'inizio della query. Questo garantisce lo stesso livello di coerenza su riga e per mutazione e tra righe all'interno della stessa istruzione DML, evitando comunque i deadlock. Nella nel caso di più aggiornamenti DML rispetto alla stessa tabella, BigQuery passa a controllo pessimistico della contemporaneità. I job di caricamento possono essere eseguiti in modo completamente indipendente e aggiunti alle tabelle.
Esegui il rollback
Se Amazon Redshift rileva un errore durante l'esecuzione di una stored procedure,
tutte le modifiche apportate in una transazione. Inoltre, puoi utilizzare la ROLLBACK
un'istruzione di controllo delle transazioni in una stored procedure per ignorare tutte le modifiche.
In BigQuery, puoi utilizzare
ROLLBACK TRANSACTION
.
Limiti per i database
Controlla il Documentazione pubblica di BigQuery per conoscere le quote e i limiti più recenti. Molte quote per gli utenti con volumi elevati possono essere contattando il team di assistenza Cloud. La tabella seguente mostra una confronto tra i limiti dei database di Amazon Redshift e BigQuery.
Limite | Amazon Redshift | BigQuery |
---|---|---|
Tabelle in ogni database per i tipi di nodi cluster grandi e xlarge | 9.900 | Senza restrizioni |
Tabelle in ogni database per tipi di nodi cluster 8xlarge | 20.000 | Senza restrizioni |
Database definiti dall'utente che puoi creare per ciascun cluster | 60 | Senza restrizioni |
Dimensione massima della riga | 4 MB | 100 MB |