Guida alla traduzione SQL di Teradata

Questo documento descrive nel dettaglio le somiglianze e le differenze nella sintassi SQL tra Teradata 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.

Tipi di dati

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

Teradata	BigQuery	Note
`INTEGER`	`INT64`
`SMALLINT`	`INT64`
`BYTEINT`	`INT64`
`BIGINT`	`INT64`
`DECIMAL`	`NUMERIC, DECIMAL` `BIGNUMERIC, BIGDECIMAL`	Utilizza l'`NUMERIC` di BigQuery (alias `DECIMAL`) quando la scala (cifre dopo il punto decimale) <= 9. Utilizza l'`BIGNUMERIC` di BigQuery (alias `BIGDECIMAL`) quando la scala è > 9. Utilizza i tipi di dati decimali parametri di BigQuery se devi applicare forzatamente limiti di cifre o di scala personalizzati (vincoli). Teradata consente di inserire valori con maggiore precisione, arrotondando il valore memorizzato, ma garantisce un'elevata precisione nei calcoli. Ciò può causare un comportamento di arrotondamento imprevisto rispetto allo standard ANSI.
`FLOAT`	`FLOAT64`
`NUMERIC`	`NUMERIC, DECIMAL` `BIGNUMERIC, BIGDECIMAL`	Utilizza l'`NUMERIC` di BigQuery (alias `DECIMAL`) quando la scala (cifre dopo il punto decimale) <= 9. Utilizza l'`BIGNUMERIC` di BigQuery (alias `BIGDECIMAL`) quando la scala è > 9. Utilizza i tipi di dati decimali parametri di BigQuery se devi applicare forzatamente limiti di cifre o di scala personalizzati (vincoli). Teradata consente di inserire valori con maggiore precisione, arrotondando il valore memorizzato, ma garantisce un'elevata precisione nei calcoli. Ciò può causare un comportamento di arrotondamento imprevisto rispetto allo standard ANSI.
`NUMBER`	`NUMERIC, DECIMAL` `BIGNUMERIC, BIGDECIMAL`	Utilizza l'`NUMERIC` di BigQuery (alias `DECIMAL`) quando la scala (cifre dopo il punto decimale) <= 9. Utilizza l'`BIGNUMERIC` di BigQuery (alias `BIGDECIMAL`) quando la scala è > 9. Utilizza i tipi di dati decimali parametri di BigQuery se devi applicare forzatamente limiti di cifre o di scala personalizzati (vincoli). Teradata consente di inserire valori con maggiore precisione, arrotondando il valore memorizzato, ma garantisce un'elevata precisione nei calcoli. Ciò può causare un comportamento di arrotondamento imprevisto rispetto allo standard ANSI.
`REAL`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	Utilizza il tipo di dati `STRING` parametrizzato di BigQuery se devi applicare un limite di lunghezza massima di caratteri.
`VARCHAR`	`STRING`	Utilizza il tipo di dati `STRING` parametrizzato di BigQuery se devi applicare un limite di lunghezza massima di caratteri.
`CLOB`	`STRING`
`JSON`	`JSON`
`BLOB`	`BYTES`
`BYTE`	`BYTES`
`VARBYTE`	`BYTES`
`DATE`	`DATE`	BigQuery non supporta una formattazione personalizzata simile a quella supportata da Teradata con DataForm in SDF.
`TIME`	`TIME`
`TIME WITH TIME ZONE`	`TIME`	Teradata archivia il tipo di dati `TIME` in UTC e ti consente di trasmettere uno scarto rispetto al fuso orario UTC utilizzando la sintassi `WITH TIME ZONE`.Il tipo di dati `TIME` in BigQuery rappresenta un'ora indipendente da qualsiasi data o fuso orario.
`TIMESTAMP`	`TIMESTAMP`	I tipi di dati Teradata e BigQuery `TIMESTAMP` hanno una precisione in microsecondi (ma Teradata supporta i secondi intercalari, al contrario di BigQuery). Entrambi i tipi di dati Teradata e BigQuery sono generalmente associati a un fuso orario UTC (dettagli).
`TIMESTAMP WITH TIME ZONE`	`TIMESTAMP`	Il `TIMESTAMP` di Teradata può essere impostato su un fuso orario diverso a livello di sistema, per utente o per colonna (utilizzando `WITH TIME ZONE`). Il tipo `TIMESTAMP` di BigQuery presuppone il fuso orario UTC se non specifichi esplicitamente un fuso orario. Assicurati di esportare correttamente le informazioni sul fuso orario (non concatenare un valore `DATE` e `TIME` senza informazioni sul fuso orario) in modo che BigQuery possa convertirlo al momento dell'importazione. In alternativa, assicurati di convertire le informazioni sul fuso orario in UTC prima di eseguire l'esportazione. BigQuery ha `DATETIME` per un'astrazione tra l'ora civile, che non mostra un fuso orario quando viene visualizzata, e `TIMESTAMP`, che è un momento preciso che mostra sempre il fuso orario UTC.
`ARRAY`	`ARRAY`
`MULTI-DIMENSIONAL ARRAY`	`ARRAY`	In BigQuery, utilizza un array di struct, ciascuno contenente un campo di tipo `ARRAY` (per maggiori dettagli, consulta la documentazione di BigQuery).
`INTERVAL HOUR`	`INT64`
`INTERVAL MINUTE`	`INT64`
`INTERVAL SECOND`	`INT64`
`INTERVAL DAY`	`INT64`
`INTERVAL MONTH`	`INT64`
`INTERVAL YEAR`	`INT64`
`PERIOD(DATE)`	`DATE`, `DATE`	`PERIOD(DATE)` deve essere convertito in due colonne `DATE` contenenti le date di inizio e fine, in modo da poter essere utilizzate con le funzioni finestra.
`PERIOD(TIMESTAMP WITH TIME ZONE)`	`TIMESTAMP`, `TIMESTAMP`
`PERIOD(TIMESTAMP)`	`TIMESTAMP`, `TIMESTAMP`
`PERIOD(TIME)`	`TIME`, `TIME`
`PERIOD(TIME WITH TIME ZONE)`	`TIME`, `TIME`
`UDT`	`STRING`
`XML`	`STRING`
`TD_ANYTYPE`	`STRING`

Per ulteriori informazioni sulla trasmissione dei tipi di dati, consulta la prossima sezione.

Formattazione del tipo Teradata

SQL di Teradata utilizza un insieme di formati predefiniti per la visualizzazione di espressioni e dati di colonne e per le conversioni tra tipi di dati. Ad esempio, un tipo di dati PERIOD(DATE) in modalità INTEGERDATE ha il formato YY/MM/DD per impostazione predefinita. Ti consigliamo di utilizzare la modalità ANSIDATE, ove possibile, per garantire la conformità SQL con ANSI, e di sfruttare questa possibilità per eseguire la pulizia dei formati legacy.

Teradata consente l'applicazione automatica di formati personalizzati utilizzando la clausola FORMAT, senza modificare lo spazio di archiviazione sottostante, come attributo di tipo di dati quando crei una tabella utilizzando DDL o in un'espressione derivata. Ad esempio, una specifica 9.99 della specifica FORMAT arrotonda qualsiasi valore FLOAT a due cifre. In BigQuery, questa funzionalità deve essere convertita utilizzando la funzione ROUND().

Questa funzionalità richiede la gestione di complessi casi limite. Ad esempio, quando la clausola FORMAT viene applicata a una colonna NUMERIC, devi tenere in considerazione regole di arrotondamento e formattazione speciali. È possibile usare una clausola FORMAT per trasmettere implicitamente un valore dell'epoca INTEGER a un formato DATE. Oppure un valore X(6) della specifica FORMAT su una colonna VARCHAR tronca il valore della colonna e devi pertanto convertirlo in una funzione SUBSTR(). Questo comportamento non è conforme allo standard ANSI SQL. Pertanto, consigliamo di non eseguire la migrazione dei formati delle colonne in BigQuery.

Se i formati colonna sono assolutamente obbligatori, utilizza gli elementi View o le funzioni definite dall'utente.

Per informazioni sui formati predefiniti utilizzati da SQL di Teradata per ogni tipo di dati, consulta la documentazione sulla formattazione predefinita di Teradata.

Formattazione di timestamp e tipo di data

La seguente tabella riassume le differenze negli elementi di formattazione di timestamp e data tra SQL Teradata e GoogleSQL.

Formato Teradata	Descrizione Teradata	BigQuery
`CURRENT_TIMESTAMP CURRENT_TIME`	Le informazioni su `TIME` e `TIMESTAMP` in Teradata possono avere informazioni sul fuso orario diverse, che vengono definite utilizzando `WITH TIME ZONE`.	Se possibile, utilizza `CURRENT_TIMESTAMP()`, che è formattato in formato ISO. Tuttavia, il formato di output mostra sempre il fuso orario UTC. (a livello interno, BigQuery non ha un fuso orario). Tieni presente i seguenti dettagli sulle differenze nel formato ISO. Il formato `DATETIME` è basato sulle convenzioni dei canali di output. Nello strumento a riga di comando di BigQuery e nella console di BigQuery, il formato viene formattato utilizzando un separatore `T` in base a RFC 3339. Tuttavia, in Python e Java JDBC, uno spazio viene utilizzato come separatore. Se vuoi usare un formato esplicito, usa `FORMAT_DATETIME()`, che consente di trasmettere una stringa esplicita. Ad esempio, la seguente espressione restituisce sempre un separatore di spazio: `CAST(CURRENT_DATETIME() AS STRING)` Teradata supporta una parola chiave `DEFAULT` nelle colonne `TIME` per impostare l'ora corrente (timestamp); questo non viene utilizzato in BigQuery.
`CURRENT_DATE`	Le date vengono archiviate in Teradata come valori `INT64` utilizzando la seguente formula: `(YEAR - 1900) * 10000 + (MONTH * 100) + DAY` Le date possono essere formattate come numeri interi.	BigQuery ha un formato `DATE` separato che restituisce sempre una data in formato ISO 8601. Impossibile utilizzare `DATE_FROM_UNIX_DATE` perché è basato sul 1970. Teradata supporta una parola chiave `DEFAULT` nelle colonne `DATE` per impostare la data corrente; questa data non viene utilizzata in BigQuery.
`CURRENT_DATE-3`	I valori delle date sono rappresentati come numeri interi. Teradata supporta gli operatori aritmetici per i tipi di date.	Per i tipi di date, utilizza `DATE_ADD()` o `DATE_SUB()`. BigQuery utilizza gli operatori aritmetici per i tipi di dati: `INT64`, `NUMERIC` e `FLOAT64`.
`SYS_CALENDAR.CALENDAR`	Teradata fornisce una visualizzazione per le operazioni del calendario che vanno oltre le operazioni sui numeri interi.	Non utilizzato in BigQuery.
`SET SESSION DATEFORM=ANSIDATE`	Imposta il formato della data della sessione o del sistema su ANSI (ISO 8601).	BigQuery utilizza sempre ISO 8601, quindi assicurati di convertire le date e le ore di Teradata.

Sintassi delle query

Questa sezione illustra le differenze nella sintassi delle query tra Teradata e BigQuery.

Istruzione `SELECT`

La maggior parte delle istruzioni SELECT di Teradata è compatibile con BigQuery. La seguente tabella contiene un elenco di differenze minori.

Teradata		BigQuery
`SEL`		Converti in `SELECT`. BigQuery non utilizza l'abbreviazione `SEL`.
`SELECT (subquery) AS flag, CASE WHEN flag = 1 THEN ...`		In BigQuery, le colonne non possono fare riferimento all'output di altre colonne definite nello stesso elenco di selezione. Preferisci spostare una sottoquery in una clausola `WITH`. `WITH flags AS ( subquery ), SELECT CASE WHEN flags.flag = 1 THEN ...`
`SELECT * FROM table WHERE A LIKE ANY ('string1', 'string2')`		BigQuery non utilizza il predicato logico `ANY`. La stessa funzionalità può essere ottenuta utilizzando più operatori `OR`: `SELECT * FROM table WHERE col LIKE 'string1' OR col LIKE 'string2'` In questo caso, anche il confronto di stringhe è diverso. Consulta la sezione Operatori di confronto.
`SELECT TOP 10 * FROM table`		BigQuery utilizza `LIMIT` alla fine di una query anziché `TOP n` che segue la parola chiave `SELECT`.

Operatori di confronto

La seguente tabella mostra gli operatori di confronto Teradata specifici di Teradata e che devono essere convertiti negli operatori conformi ad ANSI SQL:2011 utilizzati in BigQuery.

Per informazioni sugli operatori in BigQuery, consulta la sezione Operatori nella documentazione di BigQuery.

Teradata	BigQuery	Note
`exp EQ exp2` `exp IN (exp2, exp3)`	`exp = exp2` `exp IN (exp2, exp3)` Per mantenere la semantica non ANSI per `NOT CASESPECIFIC`, puoi utilizzare `RTRIM(UPPER(exp)) = RTRIM(UPPER(exp2))`	Quando confronti le stringhe per determinare l'uguaglianza, Teradata potrebbe ignorare gli spazi vuoti finali, mentre BigQuery li considera parte della stringa. Ad esempio, `'xyz'=' xyz'` è `TRUE` in Teradata ma `FALSE` in BigQuery. Teradata fornisce anche un attributo colonna `NOT CASESPECIFIC` che indica a Teradata di ignorare l'uso delle maiuscole quando si confrontano due stringhe. BigQuery è sempre specifico per il caso quando si confrontano le stringhe. Ad esempio, `'xYz' = 'xyz'` è `TRUE` in Teradata ma `FALSE` in BigQuery.
`exp LE exp2`	`exp <= exp2`
`exp LT exp2`	`exp < exp2`
`exp NE exp2`	`exp <> exp2 exp != exp2`
`exp GE exp2`	`exp >= exp2`
`exp GT exp2`	`exp > exp2`

`JOIN` condizioni

BigQuery e Teradata supportano le stesse condizioni JOIN, ON e USING. La seguente tabella contiene un elenco delle differenze minori.

Teradata	BigQuery	Note
`FROM A LEFT OUTER JOIN B ON A.date > B.start_date AND A.date < B.end_date`	`FROM A LEFT OUTER JOIN (SELECT d FROM B JOIN UNNEST(GENERATE_DATE_ARRAY(B.start_date, B.end_date)) d) B ON A.date = B.date`	BigQuery supporta clausole `JOIN` di disuguaglianza per tutti i join interni o se viene fornita almeno una condizione di uguaglianza (=), ma non solo una condizione di disuguaglianza (= e <) in `OUTER JOIN`. Questi costrutti vengono talvolta utilizzati per eseguire query su intervalli di date o di numeri interi. BigQuery impedisce agli utenti di creare inavvertitamente join incrociati di grandi dimensioni.
`FROM A, B ON A.id = B.id`	`FROM A JOIN B ON A.id = B.id`	L'utilizzo di una virgola tra le tabelle in Teradata equivale a `INNER JOIN`, mentre in BigQuery corrisponde a un `CROSS JOIN` (prodotto cartesiano). Poiché la virgola in BigQuery SQL precedente viene trattata come `UNION`, ti consigliamo di rendere esplicita l'operazione per evitare confusione.
`FROM A JOIN B ON (COALESCE(A.id , 0) = COALESCE(B.id, 0))`	`FROM A JOIN B ON (COALESCE(A.id , 0) = COALESCE(B.id, 0))`	Nessuna differenza per le funzioni scalari (costanti).
`FROM A JOIN B ON A.id = (SELECT MAX(B.id) FROM B)`	`FROM A JOIN (SELECT MAX(B.id) FROM B) B1 ON A.id = B1.id`	BigQuery impedisce agli utenti di utilizzare sottoquery, sottoquery correlate o aggregazioni nei predicati di join. In questo modo, BigQuery può caricare in contemporanea le query.

Digita conversione e trasmissione

BigQuery ha meno tipi di dati ma più ampi rispetto a Teradata, il che richiede che BigQuery sia più restrittivo nella trasmissione.

Teradata	BigQuery	Note
`exp EQ exp2` `exp IN (exp2, exp3)`	`exp = exp2` `exp IN (exp2, exp3)` Per mantenere la semantica non ANSI per `NOT CASESPECIFIC`, puoi utilizzare `RTRIM(UPPER(exp)) = RTRIM(UPPER(exp2))`	Quando confronti le stringhe per determinare l'uguaglianza, Teradata potrebbe ignorare gli spazi vuoti finali, mentre BigQuery li considera parte della stringa. Ad esempio, `'xyz'=' xyz'` è `TRUE` in Teradata ma `FALSE` in BigQuery. Teradata fornisce anche un attributo colonna `NOT CASESPECIFIC` che indica a Teradata di ignorare l'uso delle maiuscole quando si confrontano due stringhe. BigQuery è sempre specifico per il caso quando si confrontano le stringhe. Ad esempio, `'xYz' = 'xyz'` è `TRUE` in Teradata ma `FALSE` in BigQuery.
`CAST(long_varchar_column AS CHAR(6))`	`LPAD(long_varchar_column, 6)`	La trasmissione di una colonna di caratteri in Teradata a volte è utilizzata come un modo non standard e non ottimale per creare una sottostringa con spaziatura.
`CAST(92617 AS TIME) 92617 (FORMAT '99:99:99')`	`PARSE_TIME("%k%M%S", CAST(92617 AS STRING))`	Teradata esegue molte conversioni di tipo implicite e arrotondamenti in più rispetto a BigQuery, che è generalmente più restrittivo e applica gli standard ANSI. (in questo esempio viene restituito 09:26:17)
`CAST(48.5 (FORMAT 'zz') AS FLOAT)`	`CAST(SUBSTR(CAST(48.5 AS STRING), 0, 2) AS FLOAT64)`	I tipi di dati con virgola mobile e numerici possono richiedere regole di arrotondamento speciali se applicati con formati come le valute. (in questo esempio viene restituito 48)

Consulta anche Operatori di confronto e Formati colonna. Sia i confronti che la formattazione delle colonne possono comportarsi come cast di tipi.

`QUALIFY`, `ROWS` clausole

La clausola QUALIFY in Teradata consente di filtrare i risultati per le funzioni finestra. In alternativa, è possibile utilizzare una frase ROWS per la stessa attività. Questi funzionano in modo simile a una condizione HAVING per una clausola GROUP, limitando l'output delle cosiddette funzioni finestra in BigQuery.

Teradata BigQuery

SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1; La clausola QUALIFY di Teradata con una funzione finestra come ROW_NUMBER(), SUM(), COUNT() e con OVER PARTITION BY è espressa in BigQuery come una clausola WHERE su una sottoquery contenente un valore di analisi.

Con ROW_NUMBER():

SELECT col1, col2 FROM ( SELECT col1, col2, ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) RN FROM table ) WHERE RN = 1;

Utilizzo di ARRAY_AGG, che supporta partizioni più grandi:

SELECT result.* FROM ( SELECT ARRAY_AGG(table ORDER BY table.col2 DESC LIMIT 1)[OFFSET(0)] FROM table GROUP BY col1 ) AS result;

SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 ROWS BETWEEN 2 PRECEDING AND CURRENT ROW); SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 RANGE BETWEEN 2 PRECEDING AND CURRENT ROW);

In BigQuery, sia RANGE che ROWS possono essere utilizzati nella clausola relativa al frame della finestra. Tuttavia, le clausole di finestra possono essere utilizzate solo con funzioni finestra come AVG(), non con funzioni di numerazione come ROW_NUMBER().

Teradata	BigQuery
`SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1;`	La clausola `QUALIFY` di Teradata con una funzione finestra come `ROW_NUMBER()`, `SUM()`, `COUNT()` e con `OVER PARTITION BY` è espressa in BigQuery come una clausola `WHERE` su una sottoquery contenente un valore di analisi. Con `ROW_NUMBER()`: `SELECT col1, col2 FROM ( SELECT col1, col2, ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) RN FROM table ) WHERE RN = 1;` Utilizzo di `ARRAY_AGG`, che supporta partizioni più grandi: `SELECT result.* FROM ( SELECT ARRAY_AGG(table ORDER BY table.col2 DESC LIMIT 1)[OFFSET(0)] FROM table GROUP BY col1 ) AS result;`
`SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 ROWS BETWEEN 2 PRECEDING AND CURRENT ROW);`	`SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 RANGE BETWEEN 2 PRECEDING AND CURRENT ROW);` In BigQuery, sia `RANGE` che `ROWS` possono essere utilizzati nella clausola relativa al frame della finestra. Tuttavia, le clausole di finestra possono essere utilizzate solo con funzioni finestra come `AVG()`, non con funzioni di numerazione come `ROW_NUMBER()`.

`NORMALIZE` parola chiave

Teradata fornisce la parola chiave NORMALIZE per le clausole SELECT al fine di unire periodi o intervalli sovrapposti in un singolo periodo o intervallo che comprende tutti i valori dei singoli periodi.

BigQuery non supporta il tipo PERIOD, quindi qualsiasi colonna di tipo PERIOD in Teradata deve essere inserita in BigQuery come due campi DATE o DATETIME separati corrispondenti all'inizio e alla fine del periodo.

Teradata BigQuery

SELECT NORMALIZE client_id, item_sid, BEGIN(period) AS min_date, END(period) AS max_date, FROM table; SELECT t.client_id, t.item_sid, t.min_date, MAX(t.dwh_valid_to) AS max_date FROM ( SELECT d1.client_id, d1.item_sid, d1.dwh_valid_to AS dwh_valid_to, MIN(d2.dwh_valid_from) AS min_date FROM table d1 LEFT JOIN table d2 ON d1.client_id = d2.client_id AND d1.item_sid = d2.item_sid AND d1.dwh_valid_to >= d2.dwh_valid_from AND d1.dwh_valid_from < = d2.dwh_valid_to GROUP BY d1.client_id, d1.item_sid, d1.dwh_valid_to ) t GROUP BY t.client_id, t.item_sid, t.min_date;

Teradata	BigQuery
`SELECT NORMALIZE client_id, item_sid, BEGIN(period) AS min_date, END(period) AS max_date, FROM table;`	SELECT t.client_id, t.item_sid, t.min_date, MAX(t.dwh_valid_to) AS max_date FROM ( SELECT d1.client_id, d1.item_sid, d1.dwh_valid_to AS dwh_valid_to, MIN(d2.dwh_valid_from) AS min_date FROM table d1 LEFT JOIN table d2 ON d1.client_id = d2.client_id AND d1.item_sid = d2.item_sid AND d1.dwh_valid_to >= d2.dwh_valid_from AND d1.dwh_valid_from < = d2.dwh_valid_to GROUP BY d1.client_id, d1.item_sid, d1.dwh_valid_to ) t GROUP BY t.client_id, t.item_sid, t.min_date;

Funzioni

Le seguenti sezioni elencano le mappature tra le funzioni Teradata e gli equivalenti di BigQuery.

Funzioni di aggregazione

La seguente tabella mappa le funzioni di aggregazione comuni di Teradata, di aggregazione statistico e di aggregazione approssimativa ai relativi equivalenti BigQuery. BigQuery offre le seguenti funzioni aggregate aggiuntive:

Teradata	BigQuery
`AVG`	`AVG`
`BITAND`	`BIT_AND`
`BITNOT`	Operatore bit a bit (`~`)
`BITOR`	`BIT_OR`
`BITXOR`	`BIT_XOR`
`CORR`	`CORR`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`MAX`	`MAX`
`MIN`	`MIN`
`REGR_AVGX`	`AVG( IF(dep_var_expression is NULL OR ind_var_expression is NULL, NULL, ind_var_expression) )`
`REGR_AVGY`	`AVG( IF(dep_var_expression is NULL OR ind_var_expression is NULL, NULL, dep_var_expression) )`
`REGR_COUNT`	`SUM( IF(dep_var_expression is NULL OR ind_var_expression is NULL, NULL, 1) )`
`REGR_INTERCEPT`	`AVG(dep_var_expression) - AVG(ind_var_expression) * (COVAR_SAMP(ind_var_expression, dep_var_expression) / VARIANCE(ind_var_expression))`
`REGR_R2`	`(COUNT(dep_var_expression)* SUM(ind_var_expression * dep_var_expression) - SUM(dep_var_expression) * SUM(ind_var_expression)) / SQRT( (COUNT(ind_var_expression)* SUM(POWER(ind_var_expression, 2))* POWER(SUM(ind_var_expression),2))* (COUNT(dep_var_expression)* SUM(POWER(dep_var_expression, 2))* POWER(SUM(dep_var_expression), 2)))`
`REGR_SLOPE`	`- COVAR_SAMP(ind_var_expression, dep_var_expression) / VARIANCE(ind_var_expression)`
`REGR_SXX`	`SUM(POWER(ind_var_expression, 2)) - COUNT(ind_var_expression) * POWER(AVG(ind_var_expression),2)`
`REGR_SXY`	`SUM(ind_var_expression * dep_var_expression) - COUNT(ind_var_expression) * AVG(ind_var_expression) * AVG(dep_var_expression)`
`REGR_SYY`	`SUM(POWER(dep_var_expression, 2)) - COUNT(dep_var_expression) * POWER(AVG(dep_var_expression),2)`
`SKEW`	Funzione definita dall'utente dall'utente.
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`

Funzioni analitiche e funzioni finestra

La seguente tabella mappa le funzioni analitiche comuni di Teradata e le funzioni analitiche aggregate agli equivalenti delle funzione finestra BigQuery. BigQuery offre le seguenti funzioni aggiuntive:

Teradata	BigQuery
`ARRAY_AGG`	`ARRAY_AGG`
`ARRAY_CONCAT, (\|\| operator)`	`ARRAY_CONCAT_AGG, (\|\| operator)`
`BITAND`	`BIT_AND`
`BITNOT`	Operatore bit a bit (`~`)
`BITOR`	`BIT_OR`
`BITXOR`	`BIT_XOR`
`CORR`	`CORR`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`CUME_DIST`	`CUME_DIST`
`DENSE_RANK` (ANSI)	`DENSE_RANK`
`FIRST_VALUE`	`FIRST_VALUE`
`LAST_VALUE`	`LAST_VALUE`
`MAX`	`MAX`
`MIN`	`MIN`
`PERCENT_RANK`	`PERCENT_RANK`
`PERCENTILE_CONT`, `PERCENTILE_DISC`	`PERCENTILE_CONT`, `PERCENTILE_DISC`
`RANK` (ANSI)	`RANK`
`ROW_NUMBER`	`ROW_NUMBER`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`

Funzioni di data/ora

La seguente tabella mappa le funzioni di data/ora comuni di Teradata ai relativi equivalenti BigQuery. BigQuery offre le seguenti funzioni di data/ora aggiuntive:

Teradata	BigQuery
`ADD_MONTHS`	`DATE_ADD, TIMESTAMP_ADD`
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_TIME`	`CURRENT_TIME`
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`
`DATE + k`	`DATE_ADD(date_expression, INTERVAL k DAY)`
`DATE - k`	`DATE_SUB(date_expression, INTERVAL k DAY)`
`EXTRACT`	`EXTRACT(DATE), EXTRACT(TIMESTAMP)`
	`FORMAT_DATE`
	`FORMAT_DATETIME`
	`FORMAT_TIME`
	`FORMAT_TIMESTAMP`
`LAST_DAY`	`LAST_DAY` Nota: questa funzione supporta le espressioni di input `DATE` e `DATETIME`.
`MONTHS_BETWEEN`	`DATE_DIFF(date_expression, date_expression, MONTH)`
`NEXT_DAY`	`DATE_ADD( DATE_TRUNC( date_expression, WEEK(day_value) ), INTERVAL 1 WEEK )`
`OADD_MONTHS`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL num_months MONTH ), MONTH ), INTERVAL 1 DAY )`
`td_day_of_month`	`EXTRACT(DAY FROM date_expression) EXTRACT(DAY FROM timestamp_expression)`
`td_day_of_week`	`EXTRACT(DAYOFWEEK FROM date_expression) EXTRACT(DAYOFWEEK FROM timestamp_expression)`
`td_day_of_year`	`EXTRACT(DAYOFYEAR FROM date_expression) EXTRACT(DAYOFYEAR FROM timestamp_expression)`
`td_friday`	`DATE_TRUNC( date_expression, WEEK(FRIDAY) )`
`td_monday`	`DATE_TRUNC( date_expression, WEEK(MONDAY) )`
`td_month_begin`	`DATE_TRUNC(date_expression, MONTH)`
`td_month_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 MONTH ), MONTH ), INTERVAL 1 DAY )`
`td_month_of_calendar`	`(EXTRACT(YEAR FROM date_expression) - 1900) * 12 + EXTRACT(MONTH FROM date_expression)`
`td_month_of_quarter`	`EXTRACT(MONTH FROM date_expression) - ((EXTRACT(QUARTER FROM date_expression) - 1) * 3)`
`td_month_of_year`	`EXTRACT(MONTH FROM date_expression) EXTRACT(MONTH FROM timestamp_expression)`
`td_quarter_begin`	`DATE_TRUNC(date_expression, QUARTER)`
`td_quarter_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 QUARTER ), QUARTER ), INTERVAL 1 DAY )`
`td_quarter_of_calendar`	`(EXTRACT(YEAR FROM date_expression) - 1900) * 4 + EXTRACT(QUARTER FROM date_expression)`
`td_quarter_of_year`	`EXTRACT(QUARTER FROM date_expression) EXTRACT(QUARTER FROM timestamp_expression)`
`td_saturday`	`DATE_TRUNC( date_expression, WEEK(SATURDAY) )`
`td_sunday`	`DATE_TRUNC( date_expression, WEEK(SUNDAY) )`
`td_thursday`	`DATE_TRUNC( date_expression, WEEK(THURSDAY) )`
`td_tuesday`	`DATE_TRUNC( date_expression, WEEK(TUESDAY) )`
`td_wednesday`	`DATE_TRUNC( date_expression, WEEK(WEDNESDAY) )`
`td_week_begin`	`DATE_TRUNC(date_expression, WEEK)`
`td_week_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 WEEK ), WEEK ), INTERVAL 1 DAY )`
`td_week_of_calendar`	`(EXTRACT(YEAR FROM date_expression) - 1900) * 52 + EXTRACT(WEEK FROM date_expression)`
`td_week_of_month`	`EXTRACT(WEEK FROM date_expression) - EXTRACT(WEEK FROM DATE_TRUNC(date_expression, MONTH))`
`td_week_of_year`	`EXTRACT(WEEK FROM date_expression) EXTRACT(WEEK FROM timestamp_expression)`
`td_weekday_of_month`	`CAST( CEIL( EXTRACT(DAY FROM date_expression) / 7 ) AS INT64 )`
`td_year_begin`	`DATE_TRUNC(date_expression, YEAR)`
`td_year_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 YEAR ), YEAR ), INTERVAL 1 DAY )`
`td_year_of_calendar`	`EXTRACT(YEAR FROM date_expression)`
`TO_DATE`	`PARSE_DATE`
`TO_TIMESTAMP`	`PARSE_TIMESTAMP`
`TO_TIMESTAMP_TZ`	`PARSE_TIMESTAMP`

Funzioni di stringa

La seguente tabella mappa le funzioni delle stringhe Teradata ai relativi equivalenti BigQuery. BigQuery offre le seguenti funzioni stringa aggiuntive:

Teradata	BigQuery
`ASCII`	`TO_CODE_POINTS(string_expression)[OFFSET(0)]`
`CHAR2HEXINT`	`TO_HEX`
`CHARACTER LENGTH`	`CHAR_LENGTH`
`CHARACTER LENGTH`	`CHARACTER_LENGTH`
`CHR`	`CODE_POINTS_TO_STRING( [mod(numeric_expression, 256)] )`
`CONCAT, (\|\| operator)`	`CONCAT, (\|\| operator)`
`CSV`	Funzione definita dall'utente dall'utente.
`CSVLD`	Funzione definita dall'utente dall'utente.
`FORMAT`	`FORMAT`
`INDEX`	`STRPOS(string, substring)`
`INITCAP`	`INITCAP`
`INSTR`	Funzione definita dall'utente dall'utente.
`LEFT`	`SUBSTR(source_string, 1, length)`
`LENGTH`	`LENGTH`
`LOWER`	`LOWER`
`LPAD`	`LPAD`
`LTRIM`	`LTRIM`
`NGRAM`	Funzione definita dall'utente dall'utente.
`NVP`	Funzione definita dall'utente dall'utente.
`OREPLACE`	`REPLACE`
`OTRANSLATE`	Funzione definita dall'utente dall'utente.
`POSITION`	`STRPOS(string, substring)`
`REGEXP_INSTR`	`STRPOS(source_string, REGEXP_EXTRACT(source_string, regexp_string))` Nota: restituisce la prima occorrenza.
`REGEXP_REPLACE`	`REGEXP_REPLACE`
`REGEXP_SIMILAR`	`IF(REGEXP_CONTAINS,1,0)`
`REGEXP_SUBSTR`	`REGEXP_EXTRACT, REGEXP_EXTRACT_ALL`
`REGEXP_SPLIT_TO_TABLE`	Funzione definita dall'utente dall'utente.
`REVERSE`	`REVERSE`
`RIGHT`	`SUBSTR(source_string, -1, length)`
`RPAD`	`RPAD`
`RTRIM`	`RTRIM`
`STRTOK` Nota: ogni carattere nell'argomento della stringa del delimitatore viene considerato un carattere separatore separato. Il delimitatore predefinito è uno spazio.	`SPLIT(instring, delimiter)[ORDINAL(tokennum)]` Nota: l'intero argomento della stringa delimitatore viene utilizzato come delimitatore singolo. Il delimitatore predefinito è una virgola.
`STRTOK_SPLIT_TO_TABLE`	Funzione definita dall'utente dall'utente
`SUBSTRING`, `SUBSTR`	`SUBSTR`
`TRIM`	`TRIM`
`UPPER`	`UPPER`

Funzioni matematiche

La seguente tabella mappa le funzioni matematiche di Teradata ai relativi equivalenti di BigQuery. BigQuery offre le seguenti funzioni matematiche aggiuntive:

Teradata	BigQuery
`ABS`	`ABS`
`ACOS`	`ACOS`
`ACOSH`	`ACOSH`
`ASIN`	`ASIN`
`ASINH`	`ASINH`
`ATAN`	`ATAN`
`ATAN2`	`ATAN2`
`ATANH`	`ATANH`
`CEILING`	`CEIL`
`CEILING`	`CEILING`
`COS`	`COS`
`COSH`	`COSH`
`EXP`	`EXP`
`FLOOR`	`FLOOR`
`GREATEST`	`GREATEST`
`LEAST`	`LEAST`
`LN`	`LN`
`LOG`	`LOG`
`MOD` (operatore `%`)	`MOD`
`NULLIFZERO`	`NULLIF(expression, 0)`
`POWER` (operatore `**`)	`POWER, POW`
`RANDOM`	`RAND`
`ROUND`	`ROUND`
`SIGN`	`SIGN`
`SIN`	`SIN`
`SINH`	`SINH`
`SQRT`	`SQRT`
`TAN`	`TAN`
`TANH`	`TANH`
`TRUNC`	`TRUNC`
`ZEROIFNULL`	`IFNULL(expression, 0), COALESCE(expression, 0)`

Sintassi DML

In questa sezione vengono descritte le differenze nella sintassi del linguaggio di gestione dei dati tra Teradata e BigQuery.

Istruzione `INSERT`

La maggior parte delle istruzioni INSERT di Teradata è compatibile con BigQuery. La tabella seguente mostra le eccezioni.

Gli script DML in BigQuery hanno una semantica di coerenza leggermente diversa rispetto alle istruzioni equivalenti in Teradata. Per una panoramica dell'isolamento degli snapshot e della gestione di sessioni e transazioni, consulta la sezione CREATE INDEX altrove in questo documento.

Teradata BigQuery

INSERT INTO table VALUES (...); INSERT INTO table (...) VALUES (...);

Teradata offre una parola chiave DEFAULT per le colonne non null.

Nota: in BigQuery, l'omissione dei nomi delle colonne nell'istruzione INSERT funziona solo se i valori di tutte le colonne nella tabella di destinazione sono inclusi in ordine crescente in base alle loro posizioni ordinali.

Teradata	BigQuery
`INSERT INTO table VALUES (...);`	`INSERT INTO table (...) VALUES (...);` Teradata offre una parola chiave `DEFAULT` per le colonne non null. Nota: in BigQuery, l'omissione dei nomi delle colonne nell'istruzione `INSERT` funziona solo se i valori di tutte le colonne nella tabella di destinazione sono inclusi in ordine crescente in base alle loro posizioni ordinali.
`INSERT INTO table VALUES (1,2,3); INSERT INTO table VALUES (4,5,6); INSERT INTO table VALUES (7,8,9);`	`INSERT INTO table VALUES (1,2,3), (4,5,6), (7,8,9);` Teradata utilizza il concetto di richiesta a più istruzioni (MSR), che invia più istruzioni `INSERT` alla volta. In BigQuery, ciò non è consigliato a causa del limite di transazione implicito tra le istruzioni. Utilizza invece `INSERT` multivalore. BigQuery consente di utilizzare istruzioni `INSERT` simultanee, ma potrebbe mettere in coda `UPDATE`. Per migliorare le prestazioni, prendi in considerazione i seguenti approcci: Combina più righe in una singola istruzione `INSERT`, anziché una riga per ogni operazione `INSERT`. Combina più istruzioni DML (inclusa `INSERT`) utilizzando un'istruzione `MERGE`. Utilizza `CREATE TABLE ... AS SELECT` per creare e completare nuove tabelle anziché `UPDATE` o `DELETE`, in particolare quando esegui query su campi partizionati oppure esegui il rollback o il ripristino.


INSERT INTO table VALUES (1,2,3);

INSERT INTO table VALUES (4,5,6);

INSERT INTO table VALUES (7,8,9);


INSERT INTO
table VALUES (1,2,3),

                         (4,5,6),

                         (7,8,9);

Teradata utilizza il concetto di richiesta a più istruzioni (MSR), che invia più istruzioni INSERT alla volta. In BigQuery, ciò non è consigliato a causa del limite di transazione implicito tra le istruzioni. Utilizza invece INSERT multivalore.

BigQuery consente di utilizzare istruzioni INSERT simultanee, ma potrebbe mettere in coda UPDATE. Per migliorare le prestazioni, prendi in considerazione i seguenti approcci:

Combina più righe in una singola istruzione INSERT, anziché una riga per ogni operazione INSERT.
Combina più istruzioni DML (inclusa INSERT) utilizzando un'istruzione MERGE.
Utilizza CREATE TABLE ... AS SELECT per creare e completare nuove tabelle anziché UPDATE o DELETE, in particolare quando esegui query su campi partizionati oppure esegui il rollback o il ripristino.

Istruzione `UPDATE`

La maggior parte delle istruzioni UPDATE di Teradata è compatibile con BigQuery, ad eccezione dei seguenti elementi:

Quando utilizzi una clausola FROM, l'ordine delle clausole FROM e SET viene invertito in Teradata e BigQuery.
In GoogleSQL, ogni istruzione UPDATE deve includere la parola chiave WHERE, seguita da una condizione. Per aggiornare tutte le righe della tabella, utilizza WHERE true.

Come best practice, devi raggruppare più mutazioni DML invece di singole istruzioni UPDATE e INSERT. Gli script DML in BigQuery hanno una semantica di coerenza leggermente diversa rispetto alle istruzioni equivalenti di Teradata. Per una panoramica dell'isolamento degli snapshot e della gestione di sessioni e transazioni, consulta la sezione CREATE INDEX altrove in questo documento.

La seguente tabella mostra le istruzioni UPDATE di Teradata e le istruzioni BigQuery che svolgono le stesse attività.

Per ulteriori informazioni su UPDATE in BigQuery, consulta gli esempi di UPDATE di BigQuery nella documentazione di DML.

Teradata		BigQuery
`UPDATE table_A FROM table_A, table_B SET y = table_B.y, z = table_B.z + 1 WHERE table_A.x = table_B.x AND table_A.y IS NULL;`		`UPDATE table_A SET y = table_B.y, z = table_B.z + 1 FROM table_B WHERE table_A.x = table_B.x AND table_A.y IS NULL;`
`UPDATE table alias SET x = x + 1 WHERE f(x) IN (0, 1);`		`UPDATE table SET x = x + 1 WHERE f(x) IN (0, 1);`
`UPDATE table_A FROM table_A, table_B, B SET z = table_B.z WHERE table_A.x = table_B.x AND table_A.y = table_B.y;`		`UPDATE table_A SET z = table_B.z FROM table_B WHERE table_A.x = table_B.x AND table_A.y = table_B.y;`

Estratti conto `DELETE` e `TRUNCATE`

Entrambe le istruzioni DELETE e TRUNCATE consentono di rimuovere righe da una tabella senza influire sullo schema o sugli indici della tabella. TRUNCATE non viene utilizzato né in Teradata né in BigQuery. Tuttavia, puoi utilizzare le istruzioni DELETE per ottenere lo stesso effetto.

In BigQuery, l'istruzione DELETE deve avere una clausola WHERE. Per eliminare tutte le righe della tabella (tronco), utilizza WHERE true. Per velocizzare le operazioni di troncamento in caso di tabelle molto grandi, ti consigliamo di utilizzare l'istruzione CREATE OR REPLACE TABLE ... AS SELECT, utilizzando un elemento LIMIT 0 sulla stessa tabella per sostituirlo. Tuttavia, assicurati di aggiungere manualmente le informazioni di partizionamento e clustering quando le utilizzi.

Teradata svuota le righe in un secondo momento. Ciò significa che le operazioni DELETE sono inizialmente più veloci rispetto a BigQuery, ma richiedono risorse in seguito, in particolare le operazioni DELETE su larga scala che interessano la maggior parte di una tabella. Per utilizzare un approccio simile in BigQuery, ti consigliamo di ridurre il numero di operazioni DELETE, ad esempio copiando le righe da non eliminare in una nuova tabella. In alternativa, puoi rimuovere intere partizioni. Entrambe queste opzioni sono progettate per essere operazioni più veloci rispetto alle mutazioni atomiche DML.

Per ulteriori informazioni su DELETE in BigQuery, consulta gli esempi di DELETE nella documentazione di DML.

Teradata	BigQuery
`BEGIN TRANSACTION; LOCKING TABLE table_A FOR EXCLUSIVE; DELETE FROM table_A; INSERT INTO table_A SELECT * FROM table_B; END TRANSACTION;`	La sostituzione dei contenuti di una tabella con l'output della query è l'equivalente di una transazione. Puoi farlo con un'operazione di query o un'operazione di copia. Utilizzo di un'operazione di query: `bq query --replace --destination_table table_A 'SELECT * FROM table_B';` Utilizzo di un'operazione di copia: `bq cp -f table_A table_B`
`DELETE database.table ALL;`	`DELETE FROM table WHERE TRUE;` Oppure, per le tabelle molto grandi, un modo più rapido: `CREATE OR REPLACE table AS SELECT * FROM table LIMIT 0;`

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. BigQuery e Teradata seguono entrambi la sintassi ANSI.

L'operazione MERGE di Teradata è limitata alla corrispondenza delle chiavi primarie all'interno di un processore modulo di accesso (AMP). Al contrario, BigQuery non ha limiti di dimensioni o colonne per le operazioni di MERGE, pertanto l'utilizzo di MERGE è un'ottimizzazione utile. Tuttavia, se MERGE rappresenta principalmente un'eliminazione di grandi dimensioni, consulta le ottimizzazioni per DELETE in altre sezioni di questo documento.

Gli script DML in BigQuery hanno una semantica della coerenza leggermente diversa rispetto alle istruzioni equivalenti in Teradata. Ad esempio, le tabelle SET di Teradata in modalità sessione potrebbero ignorare i duplicati durante un'operazione MERGE. Per una panoramica sulla gestione delle tabelle MULTISET e SET, dell'isolamento degli snapshot e della gestione di sessioni e transazioni, consulta la sezione CREATE INDEX altrove in questo documento.

Variabili interessate dalle righe

In Teradata, la variabile ACTIVITY_COUNT è un'estensione SQL ANSI di Teradata completata con il numero di righe interessate da un'istruzione DML.

La variabile di sistema @@row_count nella funzionalità di script ha una funzionalità simile. In BigQuery sarebbe più comune controllare il valore restituito di numDmlAffectedRows negli audit log o nelle viste INFORMATION_SCHEMA.

Sintassi DDL

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

Istruzione `CREATE TABLE`

La maggior parte delle istruzioni CREATE TABLE di Teradata è compatibile con BigQuery, ad eccezione dei seguenti elementi di sintassi, che non vengono utilizzati in BigQuery:

MULTISET. Consulta la sezione CREATE INDEX.
VOLATILE. Consulta la sezione Tabelle temporanee.
[NO] FALLBACK. Consulta la sezione Rollback.
[NO] BEFORE JOURNAL, [NO] AFTER JOURNAL
CHECKSUM = DEFAULT | val
DEFAULT MERGEBLOCKRATIO
PRIMARY INDEX (col, ...). Consulta la sezione CREATE INDEX.
UNIQUE PRIMARY INDEX. Consulta la sezione CREATE INDEX.
CONSTRAINT
DEFAULT
IDENTITY

Per ulteriori informazioni su CREATE TABLE in BigQuery, consulta gli esempi di BigQuery CREATE nella documentazione di DML.

Opzioni e attributi delle colonne

Le seguenti specifiche di colonna per l'istruzione CREATE TABLE non vengono utilizzate in BigQuery:

FORMAT 'format'. Consulta la sezione relativa alla formattazione del tipo di Teradata.
CHARACTER SET name. BigQuery utilizza sempre la codifica UTF-8.
[NOT] CASESPECIFIC
COMPRESS val | (val, ...)

Teradata estende lo standard ANSI con un'opzione di colonna TITLE. Questa funzionalità può essere implementata in modo simile in BigQuery utilizzando la descrizione della colonna, come mostrato nella tabella seguente. Tieni presente che questa opzione non è disponibile per le visualizzazioni.

Teradata	BigQuery
`CREATE TABLE table ( col1 VARCHAR(30) TITLE 'column desc' );`	`CREATE TABLE dataset.table ( col1 STRING OPTIONS(description="column desc") );`

Tabelle temporanee

Teradata supporta le tabelle volatili, che vengono spesso utilizzate per archiviare i risultati intermedi negli script. Esistono diversi modi per ottenere un risultato simile alle tabelle volatili in BigQuery:

CREATE TEMPORARY TABLE può essere utilizzato nello scripting ed è valido per tutta la durata dello script. Se la tabella deve esistere oltre uno script, puoi utilizzare le altre opzioni dell'elenco.
TTL set di dati: crea un set di dati con una breve durata (ad esempio, un'ora) in modo che tutte le tabelle create nel set di dati siano effettivamente temporanee, dal momento che non durano più a lungo della durata del set di dati. Puoi far precedere tutti i nomi delle tabelle in questo set di dati con temp per indicare chiaramente che le tabelle sono temporanee.

Tabella TTL: crea una tabella che abbia una durata breve specifica utilizzando le istruzioni DDL simili alle seguenti:

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

Clausola WITH: se è necessaria una tabella temporanea solo all'interno dello stesso blocco, utilizza un risultato temporaneo utilizzando un'istruzione o una sottoquery WITH. Questa è l'opzione più efficiente.

Un pattern spesso utilizzato negli script Teradata (BTEQ) consiste nel creare una tabella permanente, inserire un valore al suo interno, utilizzare questa tabella come una tabella temporanea nelle istruzioni in corso, quindi eliminare o troncare la tabella in seguito. In pratica, utilizza la tabella come variabile costante (un semaforo). Questo approccio non è efficiente in BigQuery, pertanto ti consigliamo di utilizzare variabili reali nello Scripting o di utilizzare CREATE OR REPLACE con la sintassi delle query di AS SELECT per creare una tabella che contiene già valori.

Istruzione `CREATE VIEW`

La seguente tabella mostra gli equivalenti tra Teradata e BigQuery per l'istruzione CREATE VIEW. Le clausole per il blocco delle tabelle come LOCKING ROW FOR ACCESS non sono necessarie in BigQuery.

Teradata	BigQuery	Note
`CREATE VIEW view_name AS SELECT ...`	`CREATE VIEW view_name AS SELECT ...`
`REPLACE VIEW view_name AS SELECT ...`	`CREATE OR REPLACE VIEW view_name AS SELECT ...`
Non supportata	`CREATE VIEW IF NOT EXISTS OPTIONS(view_option_list) AS SELECT ...`	Crea una nuova vista solo se attualmente non esiste nel set di dati specificato.

Istruzione `CREATE [UNIQUE] INDEX`

Teradata richiede indici per tutte le tabelle e richiede soluzioni alternative speciali come le tabelle MULTISET e le Tabelle NoPI per funzionare con dati non univoci o non indicizzati.

BigQuery non richiede indici. Questa sezione descrive gli approcci in BigQuery a come creare funzionalità simili a quelle di utilizzo degli indici in Teradata, dove sussiste un'effettiva esigenza della logica di business.

Indicizzazione per le prestazioni

Poiché si tratta di un database orientato alle colonne con ottimizzazione delle query e dell'archiviazione, BigQuery non ha bisogno di indici espliciti. BigQuery offre funzionalità quali partizionamento e clustering, nonché campi nidificati, che possono aumentare l'efficienza e le prestazioni delle query ottimizzando la modalità di archiviazione dei dati.

Teradata non supporta le viste materializzate. Tuttavia, offre indici di join utilizzando l'istruzione CREATE JOIN INDEX, che sostanzialmente materializza i dati necessari per un join. BigQuery non ha bisogno di indici materializzati per accelerare le prestazioni, così come non ha bisogno di uno spazio di spooling dedicato per i join.

In altri casi di ottimizzazione, è possibile utilizzare le viste materializzate.

Indicizzazione per la coerenza (UNIQUE, PRIMARY INDEX)

In Teradata, è possibile utilizzare un indice univoco per impedire righe con chiavi non univoche in una tabella. Se un processo tenta di inserire o aggiornare dati che hanno un valore già presente nell'indice, l'operazione non riesce con una violazione dell'indice (tabelle MULTISET) o li ignora automaticamente (tabelle SET).

Poiché BigQuery non fornisce indici espliciti, puoi utilizzare un'istruzione MERGE per inserire solo record univoci in una tabella di destinazione da una tabella temporanea, eliminando i record duplicati. Tuttavia, non è possibile impedire a un utente con autorizzazioni di modifica di inserire un record duplicato, perché BigQuery non si blocca mai durante le operazioni di INSERT. Per generare un errore per i record duplicati in BigQuery, puoi utilizzare un'istruzione MERGE da una tabella temporanea, come mostrato nell'esempio seguente.

Teradata		BigQuery
`CREATE [UNIQUE] INDEX name;`		MERGE `prototype.FIN_MERGE` t USING `prototype.FIN_TEMP_IMPORT` m ON t.col1 = m.col1 AND t.col2 = m.col2 WHEN MATCHED THEN UPDATE SET t.col1 = ERROR(CONCAT('Encountered error for ', m.col1, ' ', m.col2)) WHEN NOT MATCHED THEN INSERT (col1,col2,col3,col4,col5,col6,col7,col8) VALUES(col1,col2,col3,col4,col5,col6,CURRENT_TIMESTAMP(),CURRENT_TIMESTAMP());

Più spesso gli utenti preferiscono rimuovere i duplicati in modo indipendente per trovare errori nei sistemi a valle.
BigQuery non supporta le colonne DEFAULT e IDENTITY (sequenze).

Indicizzazione per ottenere il blocco

Teradata fornisce risorse nel processore del modulo di accesso (AMP); le query possono consumare risorse AMP, AMP singola o di gruppo. Le istruzioni DDL sono all-AMP e pertanto sono simili a un blocco DDL globale. BigQuery non ha un meccanismo di blocco di questo tipo e può eseguire query e istruzioni INSERT in parallelo fino alla tua quota; solo le istruzioni DML UPDATE simultanee hanno determinate implicazioni di contemporaneità: le operazioni UPDATE contro la stessa partizione vengono messe in coda per garantire l'isolamento degli snapshot, in modo da non dover bloccare gli snapshot per evitare letture fantasma o aggiornamenti persi.

A causa di queste differenze, i seguenti elementi Teradata non vengono utilizzati in BigQuery:

ON COMMIT DELETE ROWS;
ON COMMIT PRESERVE ROWS;

Istruzioni SQL procedurali

Questa sezione descrive come convertire le istruzioni SQL procedurali utilizzate in stored procedure, funzioni e trigger da Teradata a BigQuery Scripting, procedure o funzioni definite dall'utente. Tutte queste informazioni possono essere verificate dagli amministratori di sistema mediante le viste INFORMATION_SCHEMA.

Istruzione `CREATE PROCEDURE`

Le stored procedure sono supportate come parte dello Scripting di BigQuery.

In BigQuery, scripting si riferisce a qualsiasi utilizzo di istruzioni di controllo, mentre le procedure sono denominate script (con argomenti se necessario) che possono essere richiamati da altri script e archiviati in modo permanente, se necessario. Una funzione definita dall'utente può essere scritta anche in JavaScript.

Teradata	BigQuery
`CREATE PROCEDURE`	`CREATE PROCEDURE` se è richiesto un nome, utilizzalo in linea con `BEGIN` o in una singola riga con `CREATE TEMP FUNCTION`.
`REPLACE PROCEDURE`	`CREATE OR REPLACE PROCEDURE`
`CALL`	`CALL`

Le sezioni seguenti descrivono i modi per convertire le istruzioni procedurali di Teradata esistenti in istruzioni di BigQuery Scripting con funzionalità simili.

Dichiarazione e assegnazione delle variabili

Le variabili BigQuery sono valide per tutta la durata dello script.

Teradata	BigQuery
`DECLARE`	`DECLARE`
`SET`	`SET`

Gestori delle condizioni di errore

Teradata utilizza gestori sui codici di stato nelle procedure per il controllo degli errori. In BigQuery, la gestione degli errori è una funzionalità fondamentale del flusso di controllo principale, simile a quella offerta da altri linguaggi con i blocchi TRY ... CATCH.

Teradata	BigQuery
`DECLARE EXIT HANDLER FOR SQLEXCEPTION`	`BEGIN ... EXCEPTION WHEN ERROR THEN`
`SIGNAL sqlstate`	`RAISE message`
`DECLARE CONTINUE HANDLER FOR SQLSTATE VALUE 23505;`	I gestori delle eccezioni che si attivano per determinate condizioni di errore non vengono utilizzati da BigQuery. Ti consigliamo di utilizzare le istruzioni `ASSERT` in cui le condizioni di uscita vengono utilizzate per i controlli preliminari o il debug, poiché è conforme ad ANSI SQL:2011.

La variabile SQLSTATE in Teradata è simile alla variabile di sistema @@error in BigQuery. In BigQuery, è più comune analizzare gli errori utilizzando l'audit logging o le viste INFORMATION_SCHEMA.

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 | WITH] ...
PREPARE stmt_id FROM sql_str;
OPEN cursor_name [USING var, ...];
FETCH cursor_name INTO var, ...;
CLOSE cursor_name;

Istruzioni SQL dinamiche

La funzionalità di script di BigQuery supporta le istruzioni SQL dinamiche come quelle mostrate nella seguente tabella.

Teradata	BigQuery
`EXECUTE IMMEDIATE sql_str;`	`EXECUTE IMMEDIATE sql_str;`
`EXECUTE stmt_id [USING var,...];`	`EXECUTE IMMEDIATE stmt_id USING var;`

Le seguenti istruzioni SQL dinamiche non vengono utilizzate in BigQuery:

PREPARE stmt_id FROM sql_str;

Istruzioni flusso di controllo

La funzionalità di creazione di script in BigQuery supporta le istruzioni di flusso di controllo come quelle mostrate nella seguente tabella.

Teradata	BigQuery
`IF condition THEN stmts ELSE stmts END IF`	`IF condition THEN stmts ELSE stmts END IF`
`label_name: LOOP stmts END LOOP label_name;`	I costrutti di blocco in stile GOTO non vengono utilizzati in BigQuery. Ti consigliamo di riscriverle come funzioni definite dall'utente (UDF) o di utilizzare istruzioni `ASSERT` quando vengono utilizzate per la gestione degli errori.
`REPEAT stmts UNTIL condition END REPEAT;`	`WHILE condition DO stmts END WHILE`
`LEAVE outer_proc_label;`	`LEAVE` non viene utilizzato per i blocchi di tipo GOTO; viene utilizzato come sinonimo di `BREAK` per abbandonare un loop `WHILE`.
`LEAVE label;`	`LEAVE` non viene utilizzato per i blocchi di tipo GOTO; viene utilizzato come sinonimo di `BREAK` per abbandonare un loop `WHILE`.
`WITH RECURSIVE temp_table AS ( ... );`	In BigQuery non vengono utilizzate le query ricorrenti, note anche come espressioni di tabella comune ricorsiva (CTE). Possono essere riscritti utilizzando array di `UNION ALL`.

Le seguenti istruzioni di flusso di controllo non vengono utilizzate in BigQuery perché BigQuery non utilizza cursori o sessioni:

FOR var AS SELECT ... DO stmts END FOR;
FOR var AS cur CURSOR FOR SELECT ... DO stmts END FOR;

Istruzioni SQL per metadati e transazioni

Teradata	BigQuery
`HELP TABLE table_name;` `HELP VIEW view_name;`	`SELECT * EXCEPT(is_generated, generation_expression, is_stored, is_updatable) FROM mydataset.INFORMATION_SCHEMA.COLUMNS; WHERE table_name=table_name` La stessa query è valida per ottenere informazioni sulle colonne delle viste. Per ulteriori informazioni, consulta Visualizzazione delle colonne in BigQuery `INFORMATION_SCHEMA`.
`SELECT * FROM dbc.tables WHERE tablekind = 'T';` (vista DBC Teradata)	`SELECT * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES;` Per saperne di più, consulta Introduzione a BigQuery `INFORMATION_SCHEMA`.
`HELP STATISTICS table_name;`	`APPROX_COUNT_DISTINCT(col)`
`COLLECT STATS USING SAMPLE ON table_name column (...);`	Non utilizzato in BigQuery.
`LOCKING TABLE table_name FOR EXCLUSIVE;`	BigQuery utilizza sempre l'isolamento degli snapshot. Per maggiori dettagli, consulta la sezione Garanzie di coerenza in questo documento.
`SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL ...`	BigQuery utilizza sempre l'isolamento snapshot. Per maggiori dettagli, consulta Garanzie di coerenza in questo documento.
`BEGIN TRANSACTION; SELECT ... END TRANSACTION;`	BigQuery utilizza sempre l'isolamento snapshot. Per maggiori dettagli, consulta Garanzie di coerenza in questo documento.
`EXPLAIN ...`	Non utilizzato in BigQuery. Funzionalità simili sono la spiegazione del piano di query nell'interfaccia utente web di BigQuery e l'allocazione degli slot visibile nelle viste `INFORMATION_SCHEMA` e nell'audit logging in Cloud Monitoring.

Istruzioni SQL a più istruzioni e multiriga

Sia Teradata sia 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.

Codici e messaggi di errore

I codici di errore Teradata e i codici di errore BigQuery sono diversi. Fornendo un'API REST, BigQuery si basa principalmente su codici di stato HTTP e su messaggi di errore dettagliati.

Se attualmente la logica dell'applicazione rileva i seguenti errori, prova a eliminare l'origine dell'errore, poiché BigQuery non restituirà gli stessi codici di errore.

SQLSTATE = '02000': "Riga non trovata"
SQLSTATE = '21000' - "Violazione della cardinalità (indice univoco)"
SQLSTATE = '22000' - "Violazione dei dati (tipo di dati)"
SQLSTATE = '23000'- "Violazione del vincolo"

In BigQuery, sarebbe più comune utilizzare le viste INFORMATION_SCHEMA o l'audit logging per visualizzare in dettaglio gli errori.

Per informazioni su come gestire gli errori nello script, consulta le sezioni seguenti.

Garanzie di coerenza e isolamento delle transazioni

Sia Teradata che BigQuery sono atomici, ovvero conformi agli ACID a livello di singola mutazione su molte righe. Ad esempio, un'operazione MERGE è completamente atomica, anche con più valori inseriti e aggiornati.

Transazioni

Teradata fornisce operazioni di lettura senza commit (consentendo letture non consentite) o un livello di isolamento della transazione serializzabile quando l'esecuzione è in modalità sessione (anziché in modalità di commit automatico). Nel migliore dei casi, Teradata raggiunge un isolamento rigorosamente serializzabile utilizzando un blocco pessimistico contro un hash di riga in tutte le colonne di righe in tutte le partizioni. Sono possibili i deadlock. DDL impone sempre un limite della transazione. I job Teradata Fastload vengono eseguiti in modo indipendente, ma solo nelle tabelle vuote.

BigQuery inoltre supporta le transazioni. BigQuery aiuta a garantire il controllo ottimistico della contemporaneità (il primo a eseguire il commit delle vittorie) tramite l'isolamento degli 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. Nel caso di più istruzioni UPDATE nella stessa tabella, BigQuery passa al controllo della contemporaneità pessimistica e mette in coda più istruzioni UPDATE, riprovando automaticamente in caso di conflitti. INSERT Le istruzioni DML e i job di caricamento possono essere eseguiti contemporaneamente e in modo indipendente per essere aggiunti alle tabelle.

Esegui il rollback

Teradata supporta due modalità di rollback delle sessioni, la modalità sessione ANSI e la modalità di sessione Teradata (SET SESSION CHARACTERISTICS e SET SESSION TRANSACTION), a seconda della modalità di rollback che preferisci. In caso di errore, potrebbe non essere eseguito il rollback della transazione.

BigQuery supporta l'istruzione ROLLBACK TRANSACTION. Non esiste un'istruzione ABORT in BigQuery.

Limiti per i database

Controlla sempre la documentazione pubblica di BigQuery per conoscere le quote e i limiti più recenti. Contattando il team di assistenza Cloud per incrementare le quote per gli utenti con volumi elevati, La seguente tabella mostra un confronto dei limiti dei database Teradata e BigQuery.

Limite	Teradata	BigQuery
Tabelle per database	Senza restrizioni	Senza restrizioni
Colonne per tabella	2048	10.000
Dimensione massima della riga	1 MB	100 MB
Lunghezza del nome di colonna e tabella	128 caratteri Unicode	16.384 caratteri Unicode
Righe per tabella	Illimitato	Illimitato
Lunghezza massima della richiesta SQL	1 MB	1 MB (lunghezza massima delle query GoogleSQL non risolte) 12 MB (lunghezza massima delle query precedenti risolte e delle query GoogleSQL) Streaming: 10 MB (limite di dimensione della richiesta HTTP) 10.000 (numero massimo di righe per richiesta)
Dimensioni massime di richieste e risposte	7 MB (richiesta), 16 MB (risposta)	10 MB (richiesta) e 10 GB (risposta) o virtualmente illimitati se utilizzi l'impaginazione o l'API Cloud Storage.
Numero massimo di sessioni simultanee	120 per motore di analisi (PE)	100 query in parallelo (possono essere generate con una prenotazione di slot), 300 richieste API in parallelo per utente.
Numero massimo di caricamenti simultanei (veloci)	30 (valore predefinito 5)	Nessun limite di contemporaneità; i job sono in coda. 100.000 job di caricamento per progetto al giorno.

Guida alla traduzione SQL di Teradata

Tipi di dati

Formattazione del tipo Teradata

Formattazione di timestamp e tipo di data

Sintassi delle query

Istruzione SELECT

Operatori di confronto

JOIN condizioni

Digita conversione e trasmissione

QUALIFY, ROWS clausole

NORMALIZE parola chiave

Funzioni

Funzioni di aggregazione

Funzioni analitiche e funzioni finestra

Funzioni di data/ora

Funzioni di stringa

Funzioni matematiche

Sintassi DML

Istruzione INSERT

Istruzione UPDATE

Estratti conto DELETE e TRUNCATE

Istruzione MERGE

Variabili interessate dalle righe

Sintassi DDL

Istruzione CREATE TABLE

Opzioni e attributi delle colonne

Tabelle temporanee

Istruzione CREATE VIEW

Istruzione CREATE [UNIQUE] INDEX

Indicizzazione per le prestazioni

Indicizzazione per la coerenza (UNIQUE, PRIMARY INDEX)

Indicizzazione per ottenere il blocco

Istruzioni SQL procedurali

Istruzione CREATE PROCEDURE

Dichiarazione e assegnazione delle variabili

Gestori delle condizioni di errore

Dichiarazioni e operazioni del cursore

Istruzioni SQL dinamiche

Istruzioni flusso di controllo

Istruzioni SQL per metadati e transazioni

Istruzioni SQL a più istruzioni e multiriga

Codici e messaggi di errore

Garanzie di coerenza e isolamento delle transazioni

Transazioni

Esegui il rollback

Limiti per i database

Istruzione `SELECT`

`JOIN` condizioni

`QUALIFY`, `ROWS` clausole

`NORMALIZE` parola chiave

Istruzione `INSERT`

Istruzione `UPDATE`

Estratti conto `DELETE` e `TRUNCATE`

Istruzione `MERGE`

Istruzione `CREATE TABLE`

Istruzione `CREATE VIEW`

Istruzione `CREATE [UNIQUE] INDEX`

Istruzione `CREATE PROCEDURE`