Questa pagina è stata tradotta dall'API Cloud Translation.

Guida alla traduzione IBM Netezza SQL

Il data warehousing IBM Netezza è progettato per funzionare con la sintassi SQL specifica di Netezza. Netezza SQL è basato su Postgres 7.2. Script SQL scritti per Netezza non possono essere utilizzate in un data warehouse BigQuery senza modifiche, poiché i dialetti SQL variano.

Questo documento illustra le analogie 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 traduzione SQL batch eseguire la migrazione collettiva degli script SQL traduzione SQL interattiva per tradurre query ad hoc. IBM Netezza SQL/NZPLSQL è supportato da entrambi gli strumenti in anteprima.

Tipi di dati

Netezza	BigQuery	Note
`INTEGER/INT/INT4`	`INT64`
`SMALLINT/INT2`	`INT64`
`BYTEINT/INT1`	`INT64`
`BIGINT/INT8`	`INT64`
`DECIMAL`	`NUMERIC`	Il tipo di dati `DECIMAL` di Netezza è alias di `NUMERIC` tipo di dati.
`NUMERIC`	`NUMERIC` `INT64`
`NUMERIC(p,s)`	`NUMERIC`	Il `NUMERIC` digita BigQuery non forza l'uso di cifre personalizzate limiti di scala (vincoli) come Netezza. BigQuery ha 9 cifre fisse dopo il separatore decimale, mentre Netezza consente configurazione personalizzata. In Nettezza, la precisione `p` può variare da 1 a 38 e la scala `s` da 0 alla precisione.
`FLOAT(p)`	`FLOAT64`
`REAL/FLOAT(6)`	`FLOAT64`
`DOUBLE PRECISION/FLOAT(14)`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	Il tipo `STRING` in BigQuery è di lunghezza variabile e non richiede l'impostazione manuale di una lunghezza massima di caratteri, come richiedono i tipi `CHARACTER` e `VARCHAR` di Netezza. Il valore predefinito valore di `n` in `CHAR(n)` è 1. La dimensione massima della stringa di caratteri è 64.000.
`VARCHAR`	`STRING`	Il tipo `STRING` in BigQuery è di lunghezza variabile e non richiede l'impostazione manuale di una lunghezza massima di caratteri, come richiedono i tipi `CHARACTER` e `VARCHAR` di Netezza. La dimensione massima della stringa di caratteri è 64.000.
`NCHAR`	`STRING`	Il tipo `STRING` in BigQuery viene archiviato come Unicode codificato UTF-8 di lunghezza variabile. La la lunghezza massima è 16.000 caratteri.
`NVARCHAR`	`STRING`	Il `STRING` digita BigQuery viene archiviato come lunghezza variabile Unicode con codifica UTF-8. La lunghezza massima è 16.000 caratteri.
`VARBINARY`	`BYTES`
`ST_GEOMETRY`	`GEOGRAPHY`
`BOOLEAN/BOOL`	`BOOL`	Il tipo `BOOL` in BigQuery può accettare solo `TRUE/FALSE`, diversamente dal tipo `BOOL` in Netezza, che può accettare una serie di valori come `0/1`, `yes/no`, `true/false,` `on/off`.
`DATE`	`DATE`
`TIME`	`TIME`
`TIMETZ/TIME WITH TIME ZONE`	`TIME`	Netezza archivia Tipo di dati `TIME` in UTC e ti consente di passare una differenza da UTC utilizzando la sintassi `WITH TIME ZONE`. Il tipo di dato `TIME` in BigQuery rappresenta un ora indipendente da qualsiasi data o fuso orario.
`TIMESTAMP`	`DATETIME`	Netezza `TIMESTAMP` non include un fuso orario, uguale a BigQuery Tipo di `DATETIME`.
	`ARRAY`	In Netezza non esiste un tipo di dato array. Il tipo di array viene invece salvato in un campo varchar.

Formattazione di timestamp e tipo di data

Per ulteriori informazioni sulla formattazione del tipo di data utilizzata da Netezza SQL, vedi il Pattern del modello Netezza Date Time documentazione. Per saperne di più sulle funzioni di data e ora, consulta la documentazione relativa alle funzioni di 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 riassunto nella tabella seguente:

Netezza	BigQuery
Le informazioni `CURRENT_TIMESTAMP` `CURRENT_TIME` `TIME` in Netezza possono avere informazioni su diversi fusi orari, 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). L'oggetto `DATETIME` nel a riga di comando bq La console Google Cloud è formattato utilizzando Separatore `T` secondo RFC 3339. Tuttavia, in Python e Java JDBC, viene utilizzato un spazio come separatore. Utilizza l'esplicita Funzione `FORMAT_DATETIME` per definire la data il formato corretto. In caso contrario, viene eseguito un trasferimento esplicito a una stringa, ad esempio: `CAST(CURRENT_DATETIME() AS STRING)` Inoltre, viene restituito un separatore di spazi.
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_DATE-3`	BigQuery non supporto aritmetico operazioni sui dati. Utilizza invece `DATE_ADD`.

Istruzione `SELECT`

In genere, l'istruzione Netezza SELECT è compatibile con in 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 all'interno della 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 all'interno della 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	Descrizione
`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
`exp >= exp2`	`exp >= exp2`	Maggiore o uguale a a
`exp > exp2`	`exp > exp2`	Maggiore di

Funzioni SQL integrate

Netezza	BigQuery	Descrizione
`CURRENT_DATE`	`CURRENT_DATE`	Recupera la data corrente (anno, mese e giorno).
`CURRENT_TIME`	`CURRENT_TIME`	Ottieni l'ora corrente con la frazione.
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`	Ottieni lo stato attuale data e ora di sistema, al secondo intero più vicino.
`NOW`	`CURRENT_TIMESTAMP`	Scarica il sistema attuale data e ora, 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)`	Aggiungere mesi a una data.
`DURATION_ADD(date, k)`	`DATE_ADD(date, INTERVAL k DAY)`	Esegui aggiunta il giorno date.
`DURATION_SUBTRACT(date, k)`	`DATE_SUB(date, INTERVAL k DAY)`	Esegui la sottrazione su le date.
`str1 \|\| str2`	`CONCAT(str1, str2)`	Concatena stringhe.

Funzioni

Questa sezione mette a confronto le funzioni 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 non bitwise: `~`
`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 di analisi

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 di negazione a livello di 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 confronta la sintassi DML di Netezza e BigQuery.

`INSERT` dichiarazione

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 nella L'istruzione `INSERT` è valida 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 le di istruzioni DML che è possibile eseguire ogni giorno. Per ottenere il massimo dalla quota, valuta i seguenti approcci: Combina più righe in un'unica istruzione `INSERT`, instead of one row per `INSERT` statement. Combina più istruzioni DML (inclusa 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 nella L'istruzione INSERT è valida 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 le di istruzioni DML che è possibile eseguire ogni giorno. Per ottenere il massimo dalla quota, valuta i seguenti approcci:

Combina più righe in un'unica istruzione INSERT, instead of one row per INSERT statement.

Combina più istruzioni DML (inclusa 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 di coerenza leggermente diversa rispetto alle istruzioni equivalenti in Netezza. Inoltre, tieni presente che BigQuery non offre vincoli a parte NOT NULL.

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

`UPDATE` dichiarazione

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

Netezza BigQuery

Netezza	BigQuery
UPDATE tbl SET tbl.col1=val1;	Non supportata 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 supportata 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 alcuni esempi, vedi Esempi di UPDATE.

A causa delle quote DML, consigliamo di utilizzare istruzioni MERGE più grandi anziché più istruzioni singolari UPDATE e INSERT. 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.

Estratti conto `DELETE` e `TRUNCATE`

Le istruzioni DELETE e TRUNCATE sono entrambi modi per rimuovere righe da una tabella senza influire sullo schema o sugli indici della tabella. 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 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 è specificato, vengono eliminate tutte le righe nella tabella Netezza.

Netezza BigQuery Descrizione

Netezza	BigQuery	Descrizione
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 farlo con un'operazione `query` o copia (`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 eliminati fisicamente, ma solo contrassegnati 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 farlo con un'operazione query o copia (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 eliminati fisicamente, ma solo contrassegnati 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.

Istruzione `MERGE`

Un'istruzione MERGE deve corrispondere a una sola riga di origine per ogni riga di destinazione. DML gli script in BigQuery hanno una semantica a coerenza leggermente diversa rispetto a quelle equivalenti di Netezza. Per una panoramica dell'isolamento degli snapshot e la gestione di sessioni e transazioni, consulta Garanzie di coerenza e isolamento delle transazioni. Per esempi, consulta Esempi di MERGE BigQuery e Esempi di MERGE Netezza.

Sintassi DDL

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

`CREATE TABLE` dichiarazione

Netezza	BigQuery	Descrizione
`TEMP` `TEMPORARY`	Con il DDL di BigQuery assistenza, puoi per creare una tabella i risultati di una query e specificare scadenza al momento della creazione nel tempo. Ad esempio, per tre giorni: `CREATE TABLE` `'fh-bigquery.public_dump.vtemp'` `OPTIONS`( `expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),` `INTERVAL 3 DAY))`	Creare tabelle temporaneo a un durante la 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 nodi, di solito con una chiave unica per una distribuzione uniforme, mentre `PARTITION BY` li riduce in segmenti.
`ORGANIZE ON`	`CLUSTER BY`	Sia Netezza che BigQuery supportano fino a quattro chiavi per il clustering. Le tabelle di base con raggruppamento (CBT) di Netezza forniscono la stessa precedenza a ciascuna delle colonne di raggruppamento. BigQuery dà la precedenza alla prima colonna su cui è raggruppata la tabella, seguita dalla seconda colonna e così via.
`ROW SECURITY`	`Authorized View`	Sicurezza a livello di riga.
`CONSTRAINT`	Non supportata	Controlla i vincoli.

Istruzione `DROP`

Netezza	BigQuery	Descrizione
`DROP TABLE`	`DROP TABLE`
`DROP DATABASE`	`DROP DATABASE`
`DROP VIEW`	`DROP VIEW`

Opzioni e attributi delle colonne

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

Tabelle temporanee

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

Per creare una tabella temporanea in BigQuery, segui questi passaggi:

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 ditemp. Ad esempio, per creare una tabella che scade tra un'ora:
```
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 NZPLSQL linguaggio di scripting compatibile 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.

`CREATE PROCEDURE` dichiarazione

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

Dichiarazione e assegnazione di variabili

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

Gestori delle eccezioni

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

Netezza	BigQuery	Descrizione
`EXCEPTION`	Non supportata	Dichiara il gestore delle eccezioni SQL per errori generici.

Istruzioni SQL dinamiche

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

Netezza	BigQuery	Descrizione
`EXECUTE IMMEDIATE` `sql_str;`	`EXECUTE IMMEDIATE` `sql_str;`	Eseguire SQL dinamico.

Istruzioni Flow-of-control

Netezza	BigQuery	Descrizione
`IF THEN ELSE STATEMENT` `IF` condition `THEN ...` `ELSE ...` `END IF;`	`IF` condition `THEN ...` `ELSE ...` `END IF;`	Esegui condizione.
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 di istruzioni del ciclo.
`EXIT WHEN`	`BREAK`	Esci da una procedura.
`WHILE condition LOOP`	`WHILE` condizione `DO ...` `END WHILE`	Esegui un loop di istruzioni finché una condizione while non ha esito negativo.

Altre affermazioni ed elementi del linguaggio procedurale

Netezza	BigQuery	Descrizione
`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 multiriga

Sia Netezza che BigQuery supportano le transazioni (sessioni) e quindi supportano le istruzioni separate da punti e virgola che vengono eseguite insieme in modo coerente. Per ulteriori informazioni, consulta la sezione Transazioni con più istruzioni.

Altre istruzioni SQL

Netezza	BigQuery	Descrizione
`GENERATE STATISTICS`		Genera statistiche per tutte le tabelle del database corrente.
`GENERATE STATISTICS ON table_name`		Genera 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 Isolamento degli snapshot. Per maggiori dettagli, vedi Coerenza di garanzie e transazione per l'isolamento.	Definisci il livello di isolamento delle transazioni.
`BEGIN TRANSACTION` `END TRANSACTION` `COMMIT`	BigQuery utilizza sempre la funzionalità Isolamento snapshot. Per maggiori dettagli, vedi Coerenza di garanzie e transazione isolamento.	Definisci il confine della transazione 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`.
Metadati delle viste utente Metadati delle viste di sistema	`SELECT` `* EXCEPT(is_typed)` `FROM` `mydataset.INFORMATION_SCHEMA.TABLES;` BigQuery Schema delle informazioni	Esegui query sugli oggetti nella database

Garanzie di coerenza e isolamento delle transazioni

Sia Netezza che BigQuery sono atomici, ovvero Conformità ACID in data un livello per 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 ANSI SQL isolamento delle transazioni. Tuttavia, indipendentemente dalla modalità specificata, viene utilizzata solo la modalità SERIALIZABLE in modo da offrire il massimo livello di coerenza possibile. Questa modalità evita letture "sporche", non ripetibili e fantasma tra transazioni simultanee. Netezza non utilizza il blocco convenzionale per applicare la coerenza. Utilizza invece il controllo delle dipendenze di serializzazione, una forma di controllo della concorrenza ottimistica per eseguire automaticamente il rollback dell'ultima transazione quando due transazioni tentano di modificare gli stessi dati.

BigQuery supporta inoltre le transazioni. BigQuery contribuisce a garantire il controllo della concorrenza ottimistico (ha la priorità chi esegue il primo commit) con l'isolamento degli snapshot, in cui una query legge gli ultimi dati committati prima dell'inizio della query. Questo approccio garantisce lo stesso livello coerenza per riga, per mutazione e tra righe all'interno dello stesso l'istruzione DML, evitando però i deadlock. Nel caso di più aggiornamenti DML rispetto nella stessa tabella, BigQuery passa controllo pessimistico della contemporaneità. I job di caricamento possono essere eseguiti in modo completamente indipendente e aggiunti alle tabelle.

Esegui il rollback

Netezza supporta Dichiarazione ROLLBACK interrompere la transazione corrente ed eseguire il rollback di tutte le modifiche apportate transazione.

In BigQuery, puoi utilizzare ROLLBACK TRANSACTION.

Limiti per i database

Limite	Netezza	BigQuery
Tabelle per database	32.000	Senza restrizioni
Colonne per tabella	1600	10000
Dimensioni massime delle righe	64 kB	100 MB
Lunghezza del nome di colonne e tabelle	128 byte	16.384 caratteri Unicode
Righe per tabella	Illimitato	Illimitato
Richiesta SQL massima lunghezza		1 MB (dimensione massima delle query SQL standard non risolte). 12 MB (numero massimo risolto legacy e standard lunghezza della query SQL). Flussi di dati: 10 MB (dimensioni della richiesta HTTP limite) 10.000 (numero massimo di righe per richiesta)
Numero massimo di richieste e dimensione risposta		10 MB (richiesta) e 10 GB (risposta) o virtualmente illimitato se utilizzi la paginazione o l'API Cloud Storage.
Numero massimo di sessioni simultanee	63 transazioni di lettura/scrittura contemporaneamente. 2000 collegamenti contemporaneamente al server.	100 query in parallelo (può essere aumentata con prenotazione slot), 300 API simultanee richieste per utente.

Passaggi successivi

Ricevi istruzioni passo passo per Eseguire la migrazione da IBM Netezza a BigQuery.

Guida alla traduzione IBM Netezza SQL

Tipi di dati

Formattazione di timestamp e tipo di data

Istruzione SELECT

Operatori di confronto

Funzioni SQL integrate

Funzioni

Funzioni di aggregazione

Funzioni di analisi

Funzioni di data e ora

Funzioni di stringa

Funzioni matematiche

Sintassi DML

INSERT dichiarazione

UPDATE dichiarazione

Estratti conto DELETE e TRUNCATE

Istruzione MERGE

Sintassi DDL

CREATE TABLE dichiarazione

Istruzione DROP

Opzioni e attributi delle colonne

Tabelle temporanee

Istruzioni SQL procedurali

CREATE PROCEDURE dichiarazione

Dichiarazione e assegnazione di variabili

Gestori delle eccezioni

Istruzioni SQL dinamiche

Istruzioni Flow-of-control

Altre affermazioni ed elementi del linguaggio procedurale

Istruzioni SQL a più istruzioni e multiriga

Altre istruzioni SQL

Garanzie di coerenza e isolamento delle transazioni

Transazioni

Esegui il rollback

Limiti per i database

Passaggi successivi

Istruzione `SELECT`

`INSERT` dichiarazione

`UPDATE` dichiarazione

Estratti conto `DELETE` e `TRUNCATE`

Istruzione `MERGE`

`CREATE TABLE` dichiarazione

Istruzione `DROP`

`CREATE PROCEDURE` dichiarazione