Questa pagina è stata tradotta dall'API Cloud Translation.

Guida alla traduzione SQL Netezza di IBM

Il data warehousing di IBM Netezza è progettato per funzionare con la sintassi SQL specifica per Netezza. Netezza SQL si basa su Postgres 7.2. Gli script SQL scritti per Netezza non possono essere utilizzati in un data warehouse BigQuery senza alterazioni, perché i dialetti SQL variano.

Questo documento descrive le somiglianze e le differenze nella sintassi SQL tra Netezza e BigQuery nelle seguenti aree:

Tipi di dati
Elementi del linguaggio SQL
Sintassi delle query
Data Manipulation Language (DML)
Data Definition Language (DDL)
Stored procedure
Funzioni

Puoi anche utilizzare la traduzione SQL in batch per eseguire la migrazione collettiva degli script SQL oppure la traduzione SQL interattiva per tradurre le query ad hoc. IBM Netezza SQL/NZPLSQL è supportato da entrambi gli strumenti in anteprima.

Tipi di dati

Netezza	BigQuery	Notes
`INTEGER/INT/INT4`	`INT64`
`SMALLINT/INT2`	`INT64`
`BYTEINT/INT1`	`INT64`
`BIGINT/INT8`	`INT64`
`DECIMAL`	`NUMERIC`	Il tipo di dati `DECIMAL` in Netezza è un alias del tipo di dati `NUMERIC`.
`NUMERIC`	`NUMERIC` `INT64`
`NUMERIC(p,s)`	`NUMERIC`	Il tipo `NUMERIC` in BigQuery non applica limiti di cifra personalizzate o di scalabilità (vincoli) come fa Netezza. BigQuery ha 9 cifre fisse dopo il decimale, mentre Netezza consente una configurazione personalizzata. In Netezza, la precisione `p` può variare da 1 a 38 e la scalabilità di `s` da 0 a 0.
`FLOAT(p)`	`FLOAT64`
`REAL/FLOAT(6)`	`FLOAT64`
`DOUBLE PRECISION/FLOAT(14)`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	Il tipo `STRING` in BigQuery ha una lunghezza variabile e non richiede l'impostazione manuale di una lunghezza massima di caratteri come richiesto dai tipi Netezza `CHARACTER` e `VARCHAR`. Il valore predefinito di `n` in `CHAR(n)` è 1. La dimensione massima della stringa di caratteri è 64.000.
`VARCHAR`	`STRING`	Il tipo `STRING` in BigQuery ha una lunghezza variabile e non richiede l'impostazione manuale di una lunghezza massima di caratteri come richiesto dai tipi Netezza `CHARACTER` e `VARCHAR`. La dimensione massima della stringa di caratteri è 64.000.
`NCHAR`	`STRING`	Il tipo `STRING` in BigQuery è archiviato come tipo Unicode con codifica UTF-8 a lunghezza variabile. La lunghezza massima è 16.000 caratteri.
`NVARCHAR`	`STRING`	Il tipo `STRING` in BigQuery è archiviato come Unicode con codifica UTF-8 a lunghezza variabile. La lunghezza massima è 16.000 caratteri.
`VARBINARY`	`BYTES`
`ST_GEOMETRY`	`GEOGRAPHY`
`BOOLEAN/BOOL`	`BOOL`	Il tipo `BOOL` in BigQuery può accettare solo `TRUE/FALSE`, a differenza del tipo `BOOL` in Netezza, che può accettare una varietà di valori come `0/1`, `yes/no` e `true/false,` `on/off`.
`DATE`	`DATE`
`TIME`	`TIME`
`TIMETZ/TIME WITH TIME ZONE`	`TIME`	Netezza archivia il tipo di dati `TIME` in UTC e ti consente di trasmettere un offset da UTC utilizzando la sintassi `WITH TIME ZONE`. Il tipo di dati `TIME` in BigQuery rappresenta un orario indipendente da qualsiasi data o fuso orario.
`TIMESTAMP`	`DATETIME`	Il tipo `TIMESTAMP` di Netezza non include un fuso orario, lo stesso del tipo `DATETIME` di BigQuery.
	`ARRAY`	Non esistono tipi di dati array in Netezza. Il tipo di array viene invece archiviato in un campo varchar.

Formattazione dei tipi di timestamp e date

Per ulteriori informazioni sulla formattazione del tipo di data utilizzata da Netezza SQL, consulta la documentazione relativa ai pattern dei modelli Date Time di Netezza. Per ulteriori informazioni sulle funzioni di data e ora, consulta la documentazione sulle funzioni data/ora di Netezza.

Quando converti gli elementi di formattazione del tipo di data da Netezza a GoogleSQL, devi prestare particolare attenzione alle differenze di fuso orario tra TIMESTAMP e DATETIME, come riepilogato nella seguente tabella:

Netezza	BigQuery
`CURRENT_TIMESTAMP` `CURRENT_TIME` Le informazioni `TIME` in Netezza possono avere informazioni sul fuso orario diverse, che vengono definite utilizzando la sintassi `WITH TIME ZONE`.	Se possibile, utilizza la funzione `CURRENT_TIMESTAMP`, che è formattata correttamente. Tuttavia, il formato di output non mostra sempre il fuso orario UTC (internamente BigQuery non ha un fuso orario). Il formato dell'oggetto `DATETIME` nello strumento a riga di comando bq e nella console Google Cloud viene formattato utilizzando un separatore `T` secondo lo standard RFC 3339. Tuttavia, in Python e JDBC Java, viene utilizzato uno spazio come separatore. Utilizza la funzione esplicita `FORMAT_DATETIME` per definire il formato di data corretto. In caso contrario, viene creato un cast esplicito a una stringa, ad esempio: `CAST(CURRENT_DATETIME() AS STRING)` Viene restituito anche un separatore di spazio.
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_DATE-3`	BigQuery non supporta operazioni su dati aritmetici. Utilizza invece la funzione `DATE_ADD`.

Estratto conto `SELECT`

In genere, l'istruzione SELECT di Netezza è compatibile con BigQuery. La tabella seguente contiene un elenco di eccezioni:

Netezza BigQuery

Netezza	BigQuery
Un'istruzione `SELECT` senza clausola `FROM`	Supporta casi speciali come i seguenti: `SELECT 1 UNION ALL SELECT 2;`
SELECT (subquery) AS flag, CASE WHEN flag = 1 THEN ...	In BigQuery, le colonne non possono fare riferimento all'output di altre colonne definite nella stessa query. Devi duplicare la logica o spostare la logica in una query nidificata. Opzione 1 SELECT (subquery) AS flag, CASE WHEN (subquery) = 1 THEN ... Opzione 2 SELECT q.*, CASE WHEN flag = 1 THEN ... FROM ( SELECT (subquery) AS flag, ... ) AS q

Un'istruzione SELECT senza clausola FROM

Supporta casi speciali come i seguenti:

SELECT 1 UNION ALL SELECT 2;


SELECT
  (subquery) AS flag,
  CASE WHEN flag = 1 THEN ...

In BigQuery, le colonne non possono fare riferimento all'output di altre colonne definite nella stessa query. Devi duplicare la logica o spostare la logica in una query nidificata.

Opzione 1


SELECT
  (subquery) AS flag,
  CASE WHEN (subquery) = 1 THEN ...

Opzione 2


SELECT
  q.*,
  CASE WHEN flag = 1 THEN ...
FROM (
  SELECT
    (subquery) AS flag,
    ...
  ) AS q

Operatori di confronto

Netezza	BigQuery	Description
`exp = exp2`	`exp = exp2`	Uguale
`exp <= exp2`	`exp <= exp2`	Minore o uguale a
`exp < exp2`	`exp < exp2`	Minore di
`exp <> exp2` `exp != exp2`	`exp <> exp2` `exp != exp2`	Diverso da
`exp >= exp2`	`exp >= exp2`	Maggiore o uguale a
`exp > exp2`	`exp > exp2`	Maggiore di

Funzioni SQL integrate

Netezza	BigQuery	Description
`CURRENT_DATE`	`CURRENT_DATE`	Visualizza la data corrente (anno, mese e giorno).
`CURRENT_TIME`	`CURRENT_TIME`	Ottieni l'ora attuale con la frazione.
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`	Ottieni la data e l'ora di sistema attuali al secondo intero più vicino.
`NOW`	`CURRENT_TIMESTAMP`	Ottieni la data e l'ora del sistema attuale fino al secondo intero più vicino.
`COALESCE(exp, 0)`	`COALESCE(exp, 0)`	Sostituisci `NULL` con zero.
`NVL(exp, 0)`	`IFNULL(exp, 0)`	Sostituisci `NULL` con zero.
`EXTRACT(DOY FROM timestamp_expression)`	`EXTRACT(DAYOFYEAR FROM timestamp_expression)`	Restituisce il numero di giorni dall'inizio dell'anno.
`ADD_MONTHS(date_expr, num_expr)`	`DATE_ADD(date, INTERVAL k MONTH)`	Aggiungi mesi a una data.
`DURATION_ADD(date, k)`	`DATE_ADD(date, INTERVAL k DAY)`	Esegui l'aggiunta in base alle date.
`DURATION_SUBTRACT(date, k)`	`DATE_SUB(date, INTERVAL k DAY)`	Esegui la sottrazione delle date.
`str1 \|\| str2`	`CONCAT(str1, str2)`	Concatena le stringhe.

Funzioni

Questa sezione mette a confronto le funzioni di Netezza e BigQuery.

Funzioni di aggregazione

Netezza	BigQuery
	`ANY_VALUE`
	`APPROX_COUNT_DISTINCT`
	`APPROX_QUANTILES`
	`APPROX_TOP_COUNT`
	`APPROX_TOP_SUM`
`AVG`	`AVG`
`intNand`	`BIT_AND`
`intNnot`	Operatore not a bit: `~`
`intNor`	`BIT_OR`
`intNxor`	`BIT_XOR`
`intNshl`
`intNshr`
`CORR`	`CORR`
`COUNT`	`COUNT`
	`COUNTIF`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`GROUPING`
	`LOGICAL_AND`
	`LOGICAL_OR`
`MAX`	`MAX`
`MIN`	`MIN`
`MEDIAN`	`PERCENTILE_CONT(x, 0.5)`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP` `STDDEV`
	`STRING_AGG`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP` `VARIANCE`

Funzioni analitiche

Netezza	BigQuery
	`ANY_VALUE`
	`ARRAY_AGG`
`ARRAY_CONCAT`	`ARRAY_CONCAT_AGG`
`ARRAY_COMBINE`
`ARRAY_COUNT`
`ARRAY_SPLIT`
`ARRAY_TYPE`
`AVG`	`AVG`
`intNand`	`BIT_AND`
`intNnot`	Operatore not a bit: `~`
`intNor`	`BIT_OR`
`intNxor`	`BIT_XOR`
`intNshl`
`intNshr`
`CORR`	`CORR`
`COUNT`	`COUNT`
	`COUNTIF`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`CUME_DIST`	`CUME_DIST`
`DENSE_RANK`	`DENSE_RANK`
`FIRST_VALUE`	`FIRST_VALUE`
`LAG`	`LAG`
`LAST_VALUE`	`LAST_VALUE`
`LEAD`	`LEAD`
`AND`	`LOGICAL_AND`
`OR`	`LOGICAL_OR`
`MAX`	`MAX`
`MIN`	`MIN`
	`NTH_VALUE`
`NTILE`	`NTILE`
`PERCENT_RANK`	`PERCENT_RANK`
`PERCENTILE_CONT`	`PERCENTILE_CONT`
`PERCENTILE_DISC`	`PERCENTILE_DISC`
`RANK`	`RANK`
`ROW_NUMBER`	`ROW_NUMBER`
`STDDEV`	`STDDEV`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP`
	`STRING_AGG`
`SUM`	`SUM`
`VARIANCE`	`VARIANCE`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP` `VARIANCE`
`WIDTH_BUCKET`

Funzioni di data e ora

Netezza	BigQuery
`ADD_MONTHS`	`DATE_ADD` `TIMESTAMP_ADD`
`AGE`
`CURRENT_DATE`	`CURRENT_DATE`
	`CURRENT_DATETIME`
`CURRENT_TIME`	`CURRENT_TIME`
`CURRENT_TIME(p)`
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`
`CURRENT_TIMESTAMP(p)`
	`DATE`
	`DATE_ADD`
	`DATE_DIFF`
	`DATE_FROM_UNIX_DATE`
	`DATE_SUB`
`DATE_TRUNC`	`DATE_TRUNC`
`DATE_PART`
	`DATETIME`
	`DATETIME_ADD`
	`DATETIME_DIFF`
	`DATETIME_SUB`
	`DATETIME_TRUNC`
`DURATION_ADD`
`DURATION_SUBTRACT`
`EXTRACT`	`EXTRACT (DATE)` `EXTRACT (TIMESTAMP)`
	`FORMAT_DATE`
	`FORMAT_DATETIME`
	`FORMAT_TIME`
	`FORMAT_TIMESTAMP`
`LAST_DAY`	`DATE_SUB(` `DATE_TRUNC(` `DATE_ADD(` `date_expression, INTERVAL 1 MONTH ), MONTH ),` `INTERVAL 1 DAY )`
`MONTHS_BETWEEN`	`DATE_DIFF(date_expression,` `date_expression, MONTH)`
`NEXT_DAY`
`NOW`
`OVERLAPS`
	`PARSE_DATE`
	`PARSE_DATETIME`
	`PARSE_TIME`
	`PARSE_TIMESTAMP`
	`STRING`
	`TIME`
	`TIME_ADD`
	`TIME_DIFF`
	`TIME_SUB`
	`TIME_TRUNC`
`TIMEOFDAY`
`TIMESTAMP`	`DATETIME`
	`TIMESTAMP_ADD`
	`TIMESTAMP_DIFF`
	`TIMESTAMP_MICROS`
	`TIMESTAMP_MILLIS`
	`TIMESTAMP_SECONDS`
	`TIMESTAMP_SUB`
	`TIMESTAMP_TRUNC`
`TIMEZONE`
`TO_DATE`	`PARSE_DATE`
`TO_TIMESTAMP`	`PARSE_TIMESTAMP`
	`UNIX_DATE`
	`UNIX_MICROS`
	`UNIX_MILLIS`
	`UNIX_SECONDS`

Funzioni di stringa

Netezza	BigQuery
`ASCII`	`TO_CODE_POINTS(string_expr)[OFFSET(0)]`
	`BYTE_LENGTH`
	`TO_HEX`
	`CHAR_LENGTH`
	`CHARACTER_LENGTH`
	`CODE_POINTS_TO_BYTES`
`BTRIM`
`CHR`	`CODE_POINTS_TO_STRING([numeric_expr])`
	`CONCAT`
`DBL_MP`
`DLE_DST`
	`ENDS_WITH`
	`FORMAT`
	`FROM_BASE32`
	`FROM_BASE64`
	`FROM_HEX`
`HEX_TO_BINARY`
`HEX_TO_GEOMETRY`
`INITCAP`
`INSTR`
`INT_TO_STRING`
`LE_DST`
`LENGTH`	`LENGTH`
`LOWER`	`LOWER`
`LPAD`	`LPAD`
`LTRIM`	`LTRIM`
	`NORMALIZE`
	`NORMALIZE_AND_CASEFOLD`
`PRI_MP`
	`REGEXP_CONTAINS`
`REGEXP_EXTRACT`	`REGEXP_EXTRACT`
`REGEXP_EXTRACT_ALL`	`REGEXP_EXTRACT_ALL`
`REGEXP_EXTRACT_ALL_SP`
`REGEXP_EXTRACT_SP`
`REGEXP_INSTR`	`STRPOS(col,` `REGEXP_EXTRACT()`)
`REGEXP_LIKE`
`REGEXP_MATCH_COUNT`
`REGEXP_REPLACE`	`REGEXP_REPLACE`
`REGEXP_REPLACE_SP`	`IF(REGEXP_CONTAINS,1,0)`
	`REGEXP_EXTRACT`
`REPEAT`	`REPEAT`
	`REPLACE`
	`REVERSE`
`RPAD`	`RPAD`
`RTRIM`	`RTRIM`
	`SAFE_CONVERT_BYTES_TO_STRING`
`SCORE_MP`
`SEC_MP`
`SOUNDEX`
	`SPLIT`
	`STARTS_WITH`
`STRING_TO_INT`
`STRPOS`	`STRPOS`
`SUBSTR`	`SUBSTR`
	`TO_BASE32`
	`TO_BASE64`
`TO_CHAR`
`TO_DATE`
`TO_NUMBER`
`TO_TIMESTAMP`
	`TO_CODE_POINTS`
	`TO_HEX`
`TRANSLATE`
	`TRIM`
`UPPER`	`UPPER`
`UNICODE`
`UNICODES`

Funzioni matematiche

Netezza	BigQuery
`ABS`	`ABS`
`ACOS`	`ACOS`
	`ACOSH`
`ASIN`	`ASIN`
	`ASINH`
`ATAN`	`ATAN`
`ATAN2`	`ATAN2`
	`ATANH`
`CEIL` `DCEIL`	`CEIL`
	`CEILING`
`COS`	`COS`
	`COSH`
`COT`	`COT`
`DEGREES`
	`DIV`
`EXP`	`EXP`
`FLOOR` `DFLOOR`	`FLOOR`
`GREATEST`	`GREATEST`
	`IEEE_DIVIDE`
	`IS_INF`
	`IS_NAN`
`LEAST`	`LEAST`
`LN`	`LN`
`LOG`	`LOG`
	`LOG10`
`MOD`	`MOD`
	`NULLIF(expr, 0)`
`PI`	`ACOS(-1)`
`POW` `FPOW`	`POWER` `POW`
`RADIANS`
`RANDOM`	`RAND`
`ROUND`	`ROUND`
	`SAFE_DIVIDE`
`SETSEED`
`SIGN`	`SIGN`
`SIN`	`SIN`
	`SINH`
`SQRT` `NUMERIC_SQRT`	`SQRT`
`TAN`	`TAN`
	`TANH`
`TRUNC`	`TRUNC`
	`IFNULL(expr, 0)`

Sintassi DML

Questa sezione mette a confronto la sintassi DML di Netezza e BigQuery.

Estratto conto `INSERT`

Netezza BigQuery

Netezza	BigQuery
INSERT INTO table VALUES (...);	INSERT INTO table (...) VALUES (...); Netezza offre una parola chiave `DEFAULT` e altri vincoli per le colonne. In BigQuery, l'omissione dei nomi delle colonne nell'istruzione `INSERT` è valido solo se tutte le colonne sono fornite.
INSERT INTO table (...) VALUES (...); INSERT INTO table (...) VALUES (...);	INSERT INTO table VALUES (), (); BigQuery impone quote DML, che limitano il numero di istruzioni DML che puoi eseguire ogni giorno. Per utilizzare al meglio la tua quota, prendi in considerazione i seguenti approcci: Combina più righe in una singola istruzione `INSERT`, anziché una riga per ogni istruzione `INSERT`. Combina più istruzioni DML (compresa un'istruzione `INSERT`) utilizzando un'istruzione `MERGE`. Utilizza un'istruzione `CREATE TABLE ... AS SELECT` per creare e compilare nuove tabelle.


INSERT INTO table VALUES (...);


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

Netezza offre una parola chiave DEFAULT e altri vincoli per le colonne. In BigQuery, l'omissione dei nomi delle colonne nell'istruzione INSERT è valido solo se tutte le colonne sono fornite.


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


INSERT INTO table VALUES (), ();

BigQuery impone quote DML, che limitano il numero di istruzioni DML che puoi eseguire ogni giorno. Per utilizzare al meglio la tua quota, prendi in considerazione i seguenti approcci:

Combina più righe in una singola istruzione INSERT, anziché una riga per ogni istruzione INSERT.

Combina più istruzioni DML (compresa un'istruzione INSERT) utilizzando un'istruzione MERGE.

Utilizza un'istruzione CREATE TABLE ... AS SELECT per creare e compilare nuove tabelle.

Gli script DML in BigQuery hanno una semantica con coerenza leggermente diversa rispetto alle istruzioni equivalenti in Netezza. Tieni inoltre presente che BigQuery non offre vincoli oltre a NOT NULL.

Per una panoramica dell'isolamento degli snapshot e della gestione di sessioni e transazioni, consulta Garanzie di coerenza e isolamento delle transazioni.

Estratto conto `UPDATE`

In Netezza, la clausola WHERE è facoltativa, ma in BigQuery è obbligatoria.

Netezza BigQuery

Netezza	BigQuery
UPDATE tbl SET tbl.col1=val1;	Non supportato senza la clausola `WHERE`. Utilizza una clausola `WHERE true` per aggiornare tutte le righe.
UPDATE A SET y = B.y, z = B.z + 1 FROM B WHERE A.x = B.x AND A.y IS NULL;	UPDATE A SET y = B.y, z = B.z + 1 FROM B WHERE A.x = B.x AND A.y IS NULL;
UPDATE A alias SET x = x + 1 WHERE f(x) IN (0, 1)	UPDATE A SET x = x + 1 WHERE f(x) IN (0, 1);
UPDATE A SET z = B.z FROM B WHERE A.x = B.x AND A.y = B.y	UPDATE A SET z = B.z FROM B WHERE A.x = B.x AND A.y = B.y;


UPDATE tbl
SET
tbl.col1=val1;

Non supportato senza la clausola WHERE. Utilizza una clausola WHERE true per aggiornare tutte le righe.


UPDATE A
SET
  y = B.y,
  z = B.z + 1
FROM B
WHERE A.x = B.x
  AND A.y IS NULL;


UPDATE A
SET
  y = B.y,
  z = B.z + 1
FROM B
WHERE A.x = B.x
  AND A.y IS NULL;


UPDATE A alias
SET x = x + 1
WHERE f(x) IN (0, 1)


UPDATE A
SET x = x + 1
WHERE f(x) IN (0, 1);


UPDATE A
SET z = B.z
FROM B
WHERE A.x = B.x
  AND A.y = B.y


UPDATE A
SET z = B.z
FROM B
WHERE A.x = B.x
  AND A.y = B.y;

Per vedere alcuni esempi, vedi gli esempi di UPDATE.

A causa delle quote DML, ti consigliamo di utilizzare istruzioni MERGE più grandi anziché più istruzioni UPDATE e INSERT singole. Gli script DML in BigQuery hanno una semantica di coerenza leggermente diversa rispetto alle istruzioni equivalenti in Netezza. Per una panoramica dell'isolamento degli snapshot e della gestione di sessioni e transazioni, consulta Garanzie di coerenza e isolamento delle transazioni.

Istruzioni `DELETE` e `TRUNCATE`

Le istruzioni DELETE e TRUNCATE consentono di rimuovere righe da una tabella senza influire sullo schema o sugli indici della tabella. L'istruzione TRUNCATE ha lo stesso effetto dell'istruzione DELETE, ma è molto più veloce dell'istruzione DELETE per le tabelle di grandi dimensioni. L'istruzione TRUNCATE è supportata in Netezza, ma non supportata in BigQuery. Tuttavia, puoi utilizzare le istruzioni DELETE sia in Netezza che in BigQuery.

In BigQuery, l'istruzione DELETE deve avere una clausola WHERE. In Netezza, la clausola WHERE è facoltativa. Se la clausola WHERE non è specificata, tutte le righe nella tabella Netezza vengono eliminate.

Netezza BigQuery Description

Netezza	BigQuery	Description
BEGIN; LOCK TABLE A IN EXCLUSIVE MODE; DELETE FROM A; INSERT INTO A SELECT * FROM B; COMMIT;	La sostituzione dei contenuti di una tabella con l'output della query è l'equivalente di una transazione. Puoi eseguire questa operazione con un'operazione `query` o copy (`cp`). bq query \ --replace \ --destination_table \ tableA \ 'SELECT * \ FROM tableB \ WHERE ...' bq cp \ -f tableA tableB	Sostituisci i contenuti di una tabella con i risultati di una query.
DELETE FROM database.table	DELETE FROM table WHERE TRUE;	In Netezza, quando viene eseguita un'istruzione di eliminazione, le righe non vengono eliminate fisicamente, ma contrassegnate solo per l'eliminazione. L'esecuzione dei comandi `GROOM TABLE` o `nzreclaim` in un secondo momento rimuove le righe contrassegnate per l'eliminazione e recupera lo spazio su disco corrispondente.
`GROOM TABLE`		Netezza utilizza il comando `GROOM TABLE` per recuperare spazio su disco rimuovendo le righe contrassegnate per l'eliminazione.


BEGIN;
LOCK TABLE A IN EXCLUSIVE MODE;
DELETE FROM A;
INSERT INTO A SELECT * FROM B;
COMMIT;

La sostituzione dei contenuti di una tabella con l'output della query è l'equivalente di una transazione. Puoi eseguire questa operazione con un'operazione query o copy (cp).


bq query \

--replace \

--destination_table \

tableA \

'SELECT * \

FROM tableB \

WHERE ...'


bq cp \

-f tableA tableB

Sostituisci i contenuti di una tabella con i risultati di una query.


DELETE FROM database.table


DELETE FROM table WHERE TRUE;

In Netezza, quando viene eseguita un'istruzione di eliminazione, le righe non vengono eliminate fisicamente, ma contrassegnate solo per l'eliminazione. L'esecuzione dei comandi GROOM TABLE o nzreclaim in un secondo momento rimuove le righe contrassegnate per l'eliminazione e recupera lo spazio su disco corrispondente.

GROOM TABLE Netezza utilizza il comando GROOM TABLE per recuperare spazio su disco rimuovendo le righe contrassegnate per l'eliminazione.

Estratto conto `MERGE`

Un'istruzione MERGE deve corrispondere al massimo a una riga di origine per ogni riga di destinazione. Gli script DML in BigQuery hanno una semantica di coerenza leggermente diversa rispetto alle istruzioni equivalenti in Netezza. Per una panoramica dell'isolamento degli snapshot e della gestione di sessioni e transazioni, consulta Garanzie di coerenza e isolamento delle transazioni. Ad esempio, vedi Esempi di BigQuery MERGE ed Esempi di Netezza MERGE.

Sintassi DDL

Questa sezione mette a confronto la sintassi DDL di Netezza e quella di BigQuery.

Estratto conto `CREATE TABLE`

Netezza	BigQuery	Description
`TEMP` `TEMPORARY`	Con il supporto DDL di BigQuery, puoi creare una tabella dai risultati di una query e specificarne la scadenza al momento della creazione. Ad esempio, per tre giorni: `CREATE TABLE` `'fh-bigquery.public_dump.vtemp'` `OPTIONS`( `expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),` `INTERVAL 3 DAY))`	Creare tabelle temporanee per una sessione.
`ZONE MAPS`	Non supportati.	Ricerca rapida della condizione `WHERE`.
`DISTRIBUTE ON`	`PARTITION BY`	Partizionamento. Questa non è una traduzione diretta. `DISTRIBUTE ON` condivide i dati tra i nodi, di solito con una chiave univoca per una distribuzione uniforme, mentre `PARTITION BY` suddivide i dati in segmenti.
`ORGANIZE ON`	`CLUSTER BY`	Sia Netezza che BigQuery supportano fino a quattro chiavi per il clustering. Le tabelle di base in cluster (CBT) Netezza hanno la stessa precedenza di ciascuna colonna di clustering. BigQuery dà la precedenza alla prima colonna in cui la tabella è clusterata, seguita dalla seconda colonna e così via.
`ROW SECURITY`	`Authorized View`	Sicurezza a livello di riga.
`CONSTRAINT`	Non supportata	Verifica i vincoli.

Estratto conto `DROP`

Netezza	BigQuery	Description
`DROP TABLE`	`DROP TABLE`
`DROP DATABASE`	`DROP DATABASE`
`DROP VIEW`	`DROP VIEW`

Opzioni e attributi delle colonne

Netezza	BigQuery	Description
`NULL` `NOT NULL`	`NULLABLE` `REQUIRED`	Specifica se la colonna può contenere valori `NULL`.
`REFERENCES`	Non supportata	Specifica il vincolo della colonna.
`UNIQUE`	Non supportata	Ogni valore nella colonna deve essere univoco.
`DEFAULT`	Non supportata	Valore predefinito per tutti i valori nella colonna.

Tabelle temporanee

Netezza supporta le tabelle TEMPORARY che esistono durante la durata di una sessione.

Per creare una tabella temporanea in BigQuery:

Crea un set di dati con una durata breve (ad esempio 12 ore).
Crea la tabella temporanea nel set di dati con un prefisso del nome della tabella temp. Ad esempio, per creare una tabella che scade dopo un'ora, procedi come segue:
```
CREATE TABLE temp.name (col1, col2, ...)
OPTIONS(expiration_timestamp = TIMESTAMP_ADD(CURRENT_TIMESTAMP(),
INTERVAL 1 HOUR));
```
Inizia a leggere e scrivere dalla tabella temporanea.

Puoi anche rimuovere i duplicati in modo indipendente per trovare errori nei sistemi downstream.

Tieni presente che BigQuery non supporta le colonne DEFAULT e IDENTITY (sequenze).

Istruzioni SQL procedurali

Netezza utilizza il linguaggio di scripting NZPLSQL per lavorare con le stored procedure. NZPLSQL si basa sul linguaggio PL/pgSQL di Postgres. Questa sezione descrive come convertire le istruzioni SQL procedurali utilizzate in stored procedure, funzioni e trigger da Netezza a BigQuery.

Estratto conto `CREATE PROCEDURE`

Netezza e BigQuery supportano entrambi la creazione di stored procedure utilizzando l'istruzione CREATE PROCEDURE. Per ulteriori informazioni, consulta Utilizzare le stored procedure SQL.

Dichiarazione e assegnazione della variabile

Netezza	BigQuery	Description
`DECLARE var datatype(len) [DEFAULT value];`	`DECLARE`	Dichiara variabile.
`SET var = value;`	`SET`	Assegna un valore alla variabile.

Gestori delle eccezioni

Netezza supporta gestori di eccezioni che possono essere attivati per determinate condizioni di errore. BigQuery non supporta i gestori di condizioni.

Netezza	BigQuery	Description
`EXCEPTION`	Non supportata	Dichiara il gestore delle eccezioni SQL per gli errori generali.

Istruzioni SQL dinamiche

Netezza supporta le query SQL dinamiche all'interno delle stored procedure. BigQuery non supporta le istruzioni SQL dinamiche.

Netezza	BigQuery	Description
`EXECUTE IMMEDIATE` `sql_str;`	`EXECUTE IMMEDIATE` `sql_str;`	Esegui SQL dinamico.

Istruzioni sul flusso di controllo

Netezza	BigQuery	Description
`IF THEN ELSE STATEMENT` `IF` condizione `THEN ...` `ELSE ...` `END IF;`	`IF` condizione `THEN ...` `ELSE ...` `END IF;`	Eseguire l'esecuzione in modo condizionale.
Controllo iterativo `FOR var AS SELECT ...` `DO` stmts `END FOR;` `FOR var AS cur CURSOR` `FOR SELECT ...` `DO stmts END FOR;`	Non supportata	Esegui l'iterazione su una raccolta di righe.
Controllo iterativo `LOOP stmts END LOOP;`	`LOOP` `sql_statement_list END LOOP;`	Blocco loop di istruzioni.
`EXIT WHEN`	`BREAK`	Esci da una procedura.
`WHILE condition LOOP`	`WHILE` condizione `DO ...` `END WHILE`	Esegue un loop di istruzioni fino a quando una condizione NOT non ha esito positivo.

Altre dichiarazioni ed elementi procedurali di linguaggio

Netezza	BigQuery	Description
`CALL` `proc(param,...)`	Non supportata	Esegui una procedura.
`EXEC` `proc(param,...)`	Non supportata	Esegui una procedura.
`EXECUTE` `proc(param,...)`	Non supportata	Esegui una procedura.

Istruzioni SQL a più istruzioni e a più righe

Sia Netezza che BigQuery supportano transazioni (sessioni) e, pertanto, supportano istruzioni separate da punto e virgola che vengono eseguite in modo coerente insieme. Per ulteriori informazioni, consulta Transazioni con più estratti conto.

Altre istruzioni SQL

Netezza	BigQuery	Description
`GENERATE STATISTICS`		Genera statistiche per tutte le tabelle nel database attuale.
`GENERATE STATISTICS ON table_name`		Generare statistiche per una tabella specifica.
`GENERATE STATISTICS ON table_name(col1,col4)`	Utilizza funzioni statistiche come `MIN, MAX, AVG,` e così via, utilizza l'interfaccia utente o l'API Cloud Data Loss Prevention.	Genera statistiche per colonne specifiche in una tabella.
`GENERATE STATISTICS ON table_name`	`APPROX_COUNT_DISTINCT(col)`	Mostra il numero di valori univoci per le colonne.
`INSERT INTO table_name`	`INSERT INTO table_name`	Inserisci una riga.
`LOCK TABLE` `table_name FOR` `EXCLUSIVE;`	Non supportata	Blocca riga.
`SET SESSION` `CHARACTERISTICS AS` `TRANSACTION ISOLATION LEVEL` ...	BigQuery utilizza sempre l'isolamento snapshot. Per maggiori dettagli, consulta Garantite di coerenza e isolamento delle transazioni.	Definisci il livello di isolamento della transazione.
`BEGIN TRANSACTION` `END TRANSACTION` `COMMIT`	BigQuery utilizza sempre l'isolamento snapshot. Per maggiori dettagli, consulta Garantite di coerenza e isolamento delle transazioni.	Definisci il confine delle transazioni per le richieste con più istruzioni.
`EXPLAIN` ...	Non supportati. Funzionalità simili nel piano di query e nella sequenza temporale	Mostra il piano di query per un'istruzione `SELECT`.
Visualizzazioni utente metadati Metadati delle viste del sistema	`SELECT` `* EXCEPT(is_typed)` `FROM` `mydataset.INFORMATION_SCHEMA.TABLES;` BigQuery Schema di informazioni	Esegui query sugli oggetti nel database

Garanzie di coerenza e isolamento delle transazioni

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

Transazioni

Netezza accetta sintatticamente tutte e quattro le modalità di isolamento delle transazioni SQL ANSI. Tuttavia, indipendentemente dalla modalità specificata, viene utilizzata solo la modalità SERIALIZABLE, che offre il massimo livello di coerenza possibile. Questa modalità evita inoltre letture sporche, non ripetibili e fantasma tra transazioni simultanee. Netezza non utilizza il blocco convenzionale per applicare la coerenza. Al contrario, utilizza il controllo delle dipendenze di serie, una forma di controllo ottimistico della contemporaneità per eseguire automaticamente il rollback dell'ultima transazione quando due transazioni tentano di modificare gli stessi dati.

BigQuery supporta inoltre le transazioni. BigQuery aiuta a garantire un controllo ottimistico della contemporaneità (il primo a commettere ha la priorità) tramite l'isolamento degli snapshot, in cui una query legge gli ultimi dati impegnati prima dell'avvio della query. Questo approccio garantisce lo stesso livello di coerenza su riga, per mutazione e tra righe all'interno della stessa istruzione DML, evitando al tempo stesso i deadlock. In caso di più aggiornamenti DML sulla stessa tabella, BigQuery passa al controllo pessimistico della contemporaneità. I job di caricamento possono essere eseguiti in modo completamente indipendente e possono essere aggiunti alle tabelle.

Esegui il rollback

Netezza supporta l'istruzione ROLLBACK per interrompere la transazione in corso ed eseguire il rollback di tutte le modifiche apportate nella transazione.

In BigQuery puoi utilizzare l'istruzione ROLLBACK TRANSACTION.

Limiti per i database

Limite	Netezza	BigQuery
Tabelle per database	32.000	Senza restrizioni
Colonne per tabella	1600	10000
Dimensione massima della riga	64 kB	100 MB
Lunghezza dei nomi di colonne e tabelle	128 byte	16.384 caratteri Unicode
Righe per tabella	Illimitato	Illimitato
Lunghezza massima delle richieste SQL		1 MB (lunghezza massima delle query SQL standard non risolte). 12 MB (lunghezza massima delle query SQL legacy e standard risolte). Streaming: 10 MB (limite di dimensione della richiesta HTTP) 10.000 (numero massimo di righe per richiesta)
Dimensione massima di richieste e risposte		10 MB (richiesta) e 10 GB (risposta) o virtualmente illimitati se si utilizza l'impaginazione o l'API Cloud Storage.
Numero massimo di sessioni simultanee	63 transazioni simultanee di lettura e scrittura. 2000 connessioni simultanee al server.	100 query in parallelo (possono essere generate con la prenotazione di slot), 300 richieste API in parallelo per utente.

Passaggi successivi

Consulta istruzioni dettagliate su Eseguire la migrazione da IBM Netezza a BigQuery.

Guida alla traduzione SQL Netezza di IBM

Tipi di dati

Formattazione dei tipi di timestamp e date

Estratto conto SELECT

Operatori di confronto

Funzioni SQL integrate

Funzioni

Funzioni di aggregazione

Funzioni analitiche

Funzioni di data e ora

Funzioni di stringa

Funzioni matematiche

Sintassi DML

Estratto conto INSERT

Estratto conto UPDATE

Istruzioni DELETE e TRUNCATE

Estratto conto MERGE

Sintassi DDL

Estratto conto CREATE TABLE

Estratto conto DROP

Opzioni e attributi delle colonne

Tabelle temporanee

Istruzioni SQL procedurali

Estratto conto CREATE PROCEDURE

Dichiarazione e assegnazione della variabile

Gestori delle eccezioni

Istruzioni SQL dinamiche

Istruzioni sul flusso di controllo

Altre dichiarazioni ed elementi procedurali di linguaggio

Istruzioni SQL a più istruzioni e a più righe

Altre istruzioni SQL

Garanzie di coerenza e isolamento delle transazioni

Transazioni

Esegui il rollback

Limiti per i database

Passaggi successivi

Estratto conto `SELECT`

Estratto conto `INSERT`

Estratto conto `UPDATE`

Istruzioni `DELETE` e `TRUNCATE`

Estratto conto `MERGE`

Estratto conto `CREATE TABLE`

Estratto conto `DROP`

Estratto conto `CREATE PROCEDURE`