Anleitung zur IBM Netezza-SQL-Übersetzung

Der IBM Netezza-Data-Warehouse-Prozess ist so ausgelegt, dass er mit der Netezza-spezifischen SQL-Syntax kompatibel ist. Netezza SQL basiert auf Postgres 7.2. Für Netezza geschriebene SQL-Skripts können nicht ohne Änderungen in einem BigQuery-Data-Warehouse verwendet werden, da die SQL-Dialekte variieren.

In diesem Dokument werden die Ähnlichkeiten und Unterschiede zwischen Netezza und BigQuery in Bezug auf die SQL-Syntax in den folgenden Bereichen beschrieben.

Datentypen
SQL-Sprachelemente
Abfragesyntax
Datenbearbeitungssprache (DML)
Datendefinitionssprache (DDL)
Gespeicherte Prozeduren
Functions

Verwenden Sie die Batch-SQL-Übersetzung, um Ihre SQL-Skripts im Bulk zu migrieren, oder die interaktive SQL-Übersetzung, um Ad-hoc-Abfragen zu übersetzen. IBM Netezza SQL/NZPLSQL wird von beiden Tools in der Vorschau unterstützt.

Datentypen

Netezza	BigQuery	Hinweise
`INTEGER/INT/INT4`	`INT64`
`SMALLINT/INT2`	`INT64`
`BYTEINT/INT1`	`INT64`
`BIGINT/INT8`	`INT64`
`DECIMAL`	`NUMERIC`	Der Datentyp `DECIMAL` in Netezza ist ein Alias für den Datentyp `NUMERIC`.
`NUMERIC`	`NUMERIC` `INT64`
`NUMERIC(p,s)`	`NUMERIC`	Der Typ `NUMERIC` in BigQuery erzwingt keine benutzerdefinierten Ziffern- oder Skalierungsgrenzen (Einschränkungen) wie Netezza. BigQuery hat feste neun Nachkommastellen, während Netezza eine benutzerdefinierte Einrichtung zulässt. In Netezza kann die Genauigkeit `p` von 1 bis 38 liegen und `s` von 0 bis zur Genauigkeit skalieren.
`FLOAT(p)`	`FLOAT64`
`REAL/FLOAT(6)`	`FLOAT64`
`DOUBLE PRECISION/FLOAT(14)`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	Der Typ `STRING` in BigQuery ist von variabler Länge und erfordert keine manuelle Festlegung einer maximalen Zeichenlänge wie die Netezza-Typen `CHARACTER` und `VARCHAR`. Der Standardwert von `n` in `CHAR(n)` ist 1. Die maximale Zeichenstringgröße beträgt 64.000.
`VARCHAR`	`STRING`	Der Typ `STRING` in BigQuery ist von variabler Länge und erfordert keine manuelle Festlegung einer maximalen Zeichenlänge wie die Netezza-Typen `CHARACTER` und `VARCHAR`. Die maximale Zeichenstringgröße beträgt 64.000.
`NCHAR`	`STRING`	Der Typ `STRING` in BigQuery wird als UTF-8-codierter Unicode mit variabler Länge gespeichert. Die maximale Länge beträgt 16.000 Zeichen.
`NVARCHAR`	`STRING`	Der Typ `STRING` in BigQuery wird als UTF-8-codierter Unicode mit variabler Länge gespeichert. Die maximale Länge beträgt 16.000 Zeichen.
`VARBINARY`	`BYTES`
`ST_GEOMETRY`	`GEOGRAPHY`
`BOOLEAN/BOOL`	`BOOL`	Der Typ `BOOL` in BigQuery kann nur `TRUE/FALSE` akzeptieren, im Gegensatz zum Typ `BOOL` in Netezza, der eine Vielzahl von Werten wie `0/1`, `yes/no`, `true/false,` `on/off` akzeptieren kann.
`DATE`	`DATE`
`TIME`	`TIME`
`TIMETZ/TIME WITH TIME ZONE`	`TIME`	Netezza speichert den Datentyp `TIME` in UTC und ermöglicht die Übergabe eines Offsets von UTC mit der Syntax `WITH TIME ZONE`. Der Datentyp `TIME` in BigQuery stellt eine Zeit dar, die unabhängig von einem Datum oder einer Zeitzone ist.
`TIMESTAMP`	`DATETIME`	Der Typ Netezza `TIMESTAMP` enthält keine Zeitzone, genauso wie der BigQuery-Typ `DATETIME`.
	`ARRAY`	In Netezza gibt es keinen Array-Datentyp. Der Arraytyp wird stattdessen in einem varchar-Feld gespeichert.

Formatierung von Zeitstempel und Datumstyp

Weitere Informationen zur Formatierung des Datumstyps, die Netezza SQL verwendet, finden Sie in der Dokumentation zu Netezza-Datumsvorlagenvorlagenmuster. Weitere Informationen zu den Datums-/Zeitfunktionen finden Sie in der Dokumentation zu Netezza-Datums- und -Uhrzeitfunktionen.

Wenn Sie Datumsformatelemente von Netezza in GoogleSQL konvertieren, müssen Sie insbesondere auf Zeitzonenunterschiede zwischen TIMESTAMP und DATETIME achten, wie in der folgenden Tabelle zusammengefasst:

Netezza	BigQuery
`CURRENT_TIMESTAMP` `CURRENT_TIME` `TIME` Informationen in Netezza können unterschiedliche Zeitzoneninformationen haben, die mit der `WITH TIME ZONE`-Syntax definiert werden.	Verwenden Sie nach Möglichkeit die Funktion `CURRENT_TIMESTAMP`, die richtig formatiert ist. Das Ausgabeformat zeigt jedoch nicht immer die UTC-Zeitzone an (intern hat BigQuery keine Zeitzone). Das Objekt `DATETIME` im bq-Befehlszeilentool und der Google Cloud Console wird gemäß dem RFC 3339 mit einem `T`-Trennzeichen formatiert. In Python und Java JDBC wird jedoch ein Leerzeichen als Trennzeichen verwendet. Mit der expliziten Funktion `FORMAT_DATETIME` können Sie das Datumsformat korrekt definieren. Andernfalls wird eine explizite Umwandlung in einen String vorgenommen, z. B. `CAST(CURRENT_DATETIME() AS STRING)` Dies gibt auch ein Leerzeichen als Trennzeichen zurück.
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_DATE-3`	BigQuery unterstützt keine arithmetischen Datenvorgänge. Nutzen Sie stattdessen die `DATE_ADD`-Funktion.

`SELECT`-Anweisung

Im Allgemeinen ist die Netezza-Anweisung SELECT mit BigQuery kompatibel. Die folgende Tabelle enthält eine Liste der Ausnahmen:

Netezza BigQuery

Netezza	BigQuery
Eine `SELECT`-Anweisung ohne `FROM`-Klausel	Unterstützt Sonderfälle wie die folgenden: `SELECT 1 UNION ALL SELECT 2;`
SELECT (subquery) AS flag, CASE WHEN flag = 1 THEN ...	In BigQuery können Spalten nicht auf die Ausgabe anderer Spalten verweisen, die in derselben Abfrage definiert sind. Sie müssen die Logik duplizieren oder in eine verschachtelte Abfrage verschieben. Option 1 SELECT (subquery) AS flag, CASE WHEN (subquery) = 1 THEN ... Option 2 SELECT q.*, CASE WHEN flag = 1 THEN ... FROM ( SELECT (subquery) AS flag, ... ) AS q

Eine SELECT-Anweisung ohne FROM-Klausel

Unterstützt Sonderfälle wie die folgenden:

SELECT 1 UNION ALL SELECT 2;


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

In BigQuery können Spalten nicht auf die Ausgabe anderer Spalten verweisen, die in derselben Abfrage definiert sind. Sie müssen die Logik duplizieren oder in eine verschachtelte Abfrage verschieben.

Option 1


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

Option 2


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

Vergleichsoperator

Netezza	BigQuery	Beschreibung
`exp = exp2`	`exp = exp2`	Gleich
`exp <= exp2`	`exp <= exp2`	Kleiner als oder gleich
`exp < exp2`	`exp < exp2`	Kleiner als
`exp <> exp2` `exp != exp2`	`exp <> exp2` `exp != exp2`	Ungleich
`exp >= exp2`	`exp >= exp2`	Größer als oder gleich
`exp > exp2`	`exp > exp2`	Größer als

Integrierte SQL-Funktionen

Netezza	BigQuery	Beschreibung
`CURRENT_DATE`	`CURRENT_DATE`	Rufen Sie das aktuelle Datum ab (Jahr, Monat und Tag).
`CURRENT_TIME`	`CURRENT_TIME`	Rufen Sie die aktuelle Zeit mit dem Bruchteil ab.
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`	Rufen Sie das aktuelle Systemdatum und die aktuelle Uhrzeit auf die nächste volle Sekunde ab.
`NOW`	`CURRENT_TIMESTAMP`	Ruft das aktuelle Systemdatum und die aktuelle Uhrzeit auf die nächste volle Sekunde ab.
`COALESCE(exp, 0)`	`COALESCE(exp, 0)`	Ersetzen Sie `NULL` durch null.
`NVL(exp, 0)`	`IFNULL(exp, 0)`	Ersetzen Sie `NULL` durch null.
`EXTRACT(DOY FROM timestamp_expression)`	`EXTRACT(DAYOFYEAR FROM timestamp_expression)`	Geben Sie die Anzahl der Tage ab Beginn des Jahres zurück.
`ADD_MONTHS(date_expr, num_expr)`	`DATE_ADD(date, INTERVAL k MONTH)`	Fügen Sie einem Datum Monate hinzu.
`DURATION_ADD(date, k)`	`DATE_ADD(date, INTERVAL k DAY)`	Fügen Sie Datumsangaben etwas hinzu.
`DURATION_SUBTRACT(date, k)`	`DATE_SUB(date, INTERVAL k DAY)`	Entfernen Sie etwas bei Datumsangaben.
`str1 \|\| str2`	`CONCAT(str1, str2)`	Verketten Sie Strings.

Funktionen

In diesem Abschnitt werden die Funktionen von Netezza und BigQuery verglichen.

Aggregatfunktionen

Netezza	BigQuery
	`ANY_VALUE`
	`APPROX_COUNT_DISTINCT`
	`APPROX_QUANTILES`
	`APPROX_TOP_COUNT`
	`APPROX_TOP_SUM`
`AVG`	`AVG`
`intNand`	`BIT_AND`
`intNnot`	Bitweiser Not-Operator: `~`
`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`

Analysefunktionen

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`	Bitweiser Not-Operator`~` ()
`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`

Funktionen für Datum und Uhrzeit

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`

Stringfunktionen

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`

Mathematische Funktionen:

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)`

DML-Syntax

In diesem Abschnitt werden die DML-Syntax von Netezza und BigQuery verglichen.

`INSERT`-Anweisung

Netezza BigQuery

Netezza	BigQuery
INSERT INTO table VALUES (...);	INSERT INTO table (...) VALUES (...); Netezza bietet einen `DEFAULT`-Suchbegriff und andere Einschränkungen für Spalten. In BigQuery ist das Weglassen von Spaltennamen in der Anweisung `INSERT` nur gültig, wenn alle Spalten angegeben sind.
INSERT INTO table (...) VALUES (...); INSERT INTO table (...) VALUES (...);	INSERT INTO table VALUES (), (); BigQuery legt DML-Kontingente fest, die die Anzahl der DML-Anweisungen begrenzen, die Sie täglich ausführen können. Ziehen Sie die folgenden Ansätze in Betracht, um Ihr Kontingent optimal zu nutzen: Kombinieren Sie mehrere Zeilen in einer einzigen `INSERT`-Anweisung anstelle einer Zeile pro `INSERT`-Anweisung. Kombinieren Sie mehrere DML-Anweisungen (einschließlich einer `INSERT`-Anweisung) mit einer `MERGE`-Anweisung. Mit einer `CREATE TABLE ... AS SELECT`-Anweisung können Sie neue Tabellen erstellen und befüllen.


INSERT INTO table VALUES (...);


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

Netezza bietet einen DEFAULT-Suchbegriff und andere Einschränkungen für Spalten. In BigQuery ist das Weglassen von Spaltennamen in der Anweisung INSERT nur gültig, wenn alle Spalten angegeben sind.


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


INSERT INTO table VALUES (), ();

BigQuery legt DML-Kontingente fest, die die Anzahl der DML-Anweisungen begrenzen, die Sie täglich ausführen können. Ziehen Sie die folgenden Ansätze in Betracht, um Ihr Kontingent optimal zu nutzen:

Kombinieren Sie mehrere Zeilen in einer einzigen INSERT-Anweisung anstelle einer Zeile pro INSERT-Anweisung.

Kombinieren Sie mehrere DML-Anweisungen (einschließlich einer INSERT-Anweisung) mit einer MERGE-Anweisung.

Mit einer CREATE TABLE ... AS SELECT-Anweisung können Sie neue Tabellen erstellen und befüllen.

DML-Skripts in BigQuery haben eine etwas andere Konsistenzsemantik als die entsprechenden Anweisungen in Netezza. Beachten Sie außerdem, dass BigQuery außer NOT NULL keine Einschränkungen bietet.

Eine Übersicht über die Snapshot-Isolation sowie die Sitzungs- und Transaktionsbehandlung finden Sie unter Konsistenzgarantien und Transaktionsisolation.

`UPDATE`-Anweisung

In Netezza ist die WHERE-Klausel optional, in BigQuery ist sie jedoch erforderlich.

Netezza BigQuery

Netezza	BigQuery
UPDATE tbl SET tbl.col1=val1;	Wird ohne die Klausel `WHERE` nicht unterstützt. Mit einer `WHERE true`-Klausel können Sie alle Zeilen aktualisieren.
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;

Wird ohne die Klausel WHERE nicht unterstützt. Mit einer WHERE true-Klausel können Sie alle Zeilen aktualisieren.


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;

Beispiele finden Sie unter Beispiele für UPDATE.

Aufgrund von DML-Kontingenten empfehlen wir die Verwendung größerer MERGE-Anweisungen anstelle mehrerer einzelner UPDATE- und INSERT-Anweisungen. DML-Skripts in BigQuery haben eine etwas andere Konsistenzsemantik als entsprechende Anweisungen in Netezza. Eine Übersicht über die Snapshot-Isolation sowie die Sitzungs- und Transaktionsbehandlung finden Sie unter Konsistenzgarantien und Transaktionsisolation.

`DELETE`- und `TRUNCATE`-Anweisungen

Die Anweisungen DELETE und TRUNCATE sind beide Möglichkeiten zum Entfernen von Zeilen aus einer Tabelle, ohne dass sich dies auf das Tabellenschema oder die Indexe auswirkt. Die Anweisung TRUNCATE hat den gleichen Effekt wie die Anweisung DELETE, ist jedoch bei großen Tabellen viel schneller als die Anweisung DELETE. Die TRUNCATE-Anweisung wird in Netezza unterstützt, aber nicht in BigQuery. Sie können jedoch DELETE-Anweisungen sowohl in Netezza als auch in BigQuery verwenden.

In BigQuery muss die DELETE-Anweisung eine WHERE-Klausel enthalten. In Netezza ist die WHERE-Klausel optional. Wenn die Klausel WHERE nicht angegeben ist, werden alle Zeilen in der Netezza-Tabelle gelöscht.

Netezza BigQuery Beschreibung

Netezza	BigQuery	Beschreibung
BEGIN; LOCK TABLE A IN EXCLUSIVE MODE; DELETE FROM A; INSERT INTO A SELECT * FROM B; COMMIT;	Das Ersetzen des Inhalts einer Tabelle durch die Abfrageausgabe entspricht einer Transaktion. Sie können dazu entweder einen `query`oder einen Kopiervorgang (`cp`) verwenden. bq query \ --replace \ --destination_table \ tableA \ 'SELECT * \ FROM tableB \ WHERE ...' bq cp \ -f tableA tableB	Ersetzen Sie den Inhalt einer Tabelle durch die Ergebnisse einer Abfrage.
DELETE FROM database.table	DELETE FROM table WHERE TRUE;	In Netezza werden bei der Ausführung einer Löschanweisung die Zeilen nicht physisch gelöscht, sondern nur zum Löschen markiert. Wenn Sie später die Befehle `GROOM TABLE` oder `nzreclaim` ausführen, werden die zum Löschen markierten Zeilen entfernt und der entsprechende Speicherplatz wird freigegeben.
`GROOM TABLE`		Netezza verwendet den Befehl `GROOM TABLE`, um Speicherplatz zurückzugewinnen, indem Zeilen gelöscht werden, die zum Löschen markiert sind.


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

Das Ersetzen des Inhalts einer Tabelle durch die Abfrageausgabe entspricht einer Transaktion. Sie können dazu entweder einen queryoder einen Kopiervorgang (cp) verwenden.


bq query \

--replace \

--destination_table \

tableA \

'SELECT * \

FROM tableB \

WHERE ...'


bq cp \

-f tableA tableB

Ersetzen Sie den Inhalt einer Tabelle durch die Ergebnisse einer Abfrage.


DELETE FROM database.table


DELETE FROM table WHERE TRUE;

In Netezza werden bei der Ausführung einer Löschanweisung die Zeilen nicht physisch gelöscht, sondern nur zum Löschen markiert. Wenn Sie später die Befehle GROOM TABLE oder nzreclaim ausführen, werden die zum Löschen markierten Zeilen entfernt und der entsprechende Speicherplatz wird freigegeben.

GROOM TABLE Netezza verwendet den Befehl GROOM TABLE, um Speicherplatz zurückzugewinnen, indem Zeilen gelöscht werden, die zum Löschen markiert sind.

`MERGE`-Anweisung

Eine MERGE-Anweisung muss mit maximal einer Quellzeile für jede Zielzeile übereinstimmen. DML-Skripts in BigQuery haben eine etwas andere Konsistenzsemantik als die entsprechenden Anweisungen in Netezza. Eine Übersicht über die Snapshot-Isolation sowie die Sitzungs- und Transaktionsbehandlung finden Sie unter Konsistenzgarantien und Transaktionsisolation. Beispiele finden Sie in BigQuery-MERGE-Beispiele und Netezza-MERGE-Beispiele.

DDL-Syntax

In diesem Abschnitt werden die Netezza- und BigQuery-DDL-Syntax verglichen.

`CREATE TABLE`-Anweisung

Netezza	BigQuery	Beschreibung
`TEMP` `TEMPORARY`	Mit der DDL-Unterstützung von BigQuery können Sie eine Tabelle aus den Ergebnissen einer Abfrage erstellen und deren Ablaufzeit bei der Erstellung angeben. Zum Beispiel für drei Tage: `CREATE TABLE` `'fh-bigquery.public_dump.vtemp'` `OPTIONS`( `expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),` `INTERVAL 3 DAY))`	Erstellen Sie für eine Sitzung temporäre Tabellen in einer Sitzung.
`ZONE MAPS`	Nicht unterstützt.	Schnellsuche nach der Bedingung `WHERE`.
`DISTRIBUTE ON`	`PARTITION BY`	Partitionierung. Das ist keine direkte Übersetzung. `DISTRIBUTE ON` teilt Daten mit verschiedenen Knoten, normalerweise mit einem eindeutigen Schlüssel, um die Verteilung gleichmäßig zu halten, während `PARTITION BY` die Daten in Segmente bereinigt.
`ORGANIZE ON`	`CLUSTER BY`	Sowohl Netezza als auch BigQuery unterstützen bis zu vier Schlüssel für das Clustering. Netezza geclusterte Basistabellen (CBT) haben für jede Clustering-Spalte die gleiche Priorität. BigQuery priorisiert die erste Spalte, nach der die Tabelle geclustert wird, gefolgt von der zweiten Spalte usw.
`ROW SECURITY`	`Authorized View`	Sicherheit auf Zeilenebene.
`CONSTRAINT`	Nicht unterstützt	Einschränkungen prüfen.

`DROP`-Anweisung

Netezza	BigQuery	Beschreibung
`DROP TABLE`	`DROP TABLE`
`DROP DATABASE`	`DROP DATABASE`
`DROP VIEW`	`DROP VIEW`

Optionen und Attribute für Spalten

Netezza	BigQuery	Beschreibung
`NULL` `NOT NULL`	`NULLABLE` `REQUIRED`	Geben Sie an, ob die Spalte `NULL`-Werte enthalten darf.
`REFERENCES`	Nicht unterstützt	Spalteneinschränkung angeben
`UNIQUE`	Nicht unterstützt	Jeder Wert in der Spalte muss eindeutig sein.
`DEFAULT`	Nicht unterstützt	Standardwert für alle Werte in der Spalte.

Temporäre Tabellen

Netezza unterstützt TEMPORARY-Tabellen, die während einer Sitzung vorhanden sind.

So erstellen Sie eine temporäre Tabelle in BigQuery:

Erstellen Sie ein Dataset mit einer kurzen Lebensdauer (z. B. 12 Stunden).
Erstellen Sie die temporäre Tabelle im Dataset mit dem Tabellennamenspräfix temp. So erstellen Sie beispielsweise eine Tabelle, die in einer Stunde abläuft:
```
CREATE TABLE temp.name (col1, col2, ...)
OPTIONS(expiration_timestamp = TIMESTAMP_ADD(CURRENT_TIMESTAMP(),
INTERVAL 1 HOUR));
```
Sie können mit dem Lesen und Schreiben aus der temporären Tabelle beginnen.

Sie können auch Duplikate unabhängig entfernen, um Fehler in nachgelagerten Systemen zu finden.

BigQuery unterstützt die Spalten DEFAULT und IDENTITY (Sequenzen) nicht.

Prozedurale SQL-Anweisungen

Netezza verwendet die Skriptsprache NZPLSQL, um mit gespeicherten Prozeduren zu arbeiten. NZPLSQL basiert auf der PL/pgSQL-Sprache von Postgres. In diesem Abschnitt wird beschrieben, wie Sie prozedurale SQL-Anweisungen, die in gespeicherten Verfahren, Funktionen und Triggern verwendet werden, von Netezza in BigQuery konvertieren.

`CREATE PROCEDURE`-Anweisung

Netezza und BigQuery unterstützen das Erstellen gespeicherter Prozeduren mithilfe der Anweisung CREATE PROCEDURE. Weitere Informationen finden Sie unter Mit SQL-gespeicherten Prozeduren arbeiten.

Variablendeklaration und -zuweisung

Netezza	BigQuery	Beschreibung
`DECLARE var datatype(len) [DEFAULT value];`	`DECLARE`	Variable deklarieren.
`SET var = value;`	`SET`	Weisen Sie der Variable einen Wert zu.

Ausnahme-Handler

Netezza unterstützt Ausnahme-Handler, die für bestimmte Fehlerbedingungen ausgelöst werden können. BigQuery unterstützt keine Bedingungs-Handler.

Netezza	BigQuery	Beschreibung
`EXCEPTION`	Nicht unterstützt	Deklarieren Sie den SQL-Ausnahme-Handler für allgemeine Fehler.

Dynamische SQL-Anweisungen

Netezza unterstützt dynamische SQL-Abfragen in gespeicherten Prozeduren. BigQuery unterstützt keine dynamischen SQL-Anweisungen.

Netezza	BigQuery	Beschreibung
`EXECUTE IMMEDIATE` `sql_str;`	`EXECUTE IMMEDIATE` `sql_str;`	Dynamischen SQL ausführen.

Anweisungen zum Kontrollfluss

Netezza	BigQuery	Beschreibung
`IF THEN ELSE STATEMENT` `IF` Bedingung `THEN ...` `ELSE ...` `END IF;`	`IF` Bedingung `THEN ...` `ELSE ...` `END IF;`	Mit einer Bedingung ausführen.
Iterative Kontrolle `FOR var AS SELECT ...` `DO` stmts `END FOR;` `FOR var AS cur CURSOR` `FOR SELECT ...` `DO stmts END FOR;`	Nicht unterstützt	Für eine Sammlung von Zeilen iterieren.
Iterative Kontrolle `LOOP stmts END LOOP;`	`LOOP` `sql_statement_list END LOOP;`	Loop-Block von Anweisungen.
`EXIT WHEN`	`BREAK`	Beenden Sie ein Verfahren.
`WHILE condition LOOP`	`WHILE` Bedingung `DO ...` `END WHILE`	Führen Sie eine Schleife von Anweisungen aus, bis eine while-Bedingung fehlschlägt.

Andere Aussagen und Elemente der prozeduralen Sprache

Netezza	BigQuery	Beschreibung
`CALL` `proc(param,...)`	Nicht unterstützt	Führt ein Verfahren aus.
`EXEC` `proc(param,...)`	Nicht unterstützt	Führt ein Verfahren aus.
`EXECUTE` `proc(param,...)`	Nicht unterstützt	Führt ein Verfahren aus.

Mehrfachanweisungen und mehrzeilige SQL-Anweisungen

Sowohl Netezza als auch BigQuery unterstützen Transaktionen (Sitzungen) und unterstützen daher durch Semikolons getrennte Anweisungen, die konsistent zusammen ausgeführt werden. Weitere Informationen finden Sie unter Transaktionen mit mehreren Anweisungen.

Weitere SQL-Anweisungen

Netezza	BigQuery	Beschreibung
`GENERATE STATISTICS`		Statistiken für alle Tabellen in der aktuellen Datenbank erstellen.
`GENERATE STATISTICS ON table_name`		Statistiken für eine bestimmte Tabelle erstellen.
`GENERATE STATISTICS ON table_name(col1,col4)`	Verwenden Sie entweder statistische Funktionen wie `MIN, MAX, AVG,` usw., die UI oder die Cloud Data Loss Prevention API.	Statistiken für bestimmte Spalten in einer Tabelle generieren.
`GENERATE STATISTICS ON table_name`	`APPROX_COUNT_DISTINCT(col)`	Die Anzahl der eindeutigen Werte für Spalten anzeigen.
`INSERT INTO table_name`	`INSERT INTO table_name`	Eine Zeile einfügen.
`LOCK TABLE` `table_name FOR` `EXCLUSIVE;`	Nicht unterstützt	Zeile sperren.
`SET SESSION` `CHARACTERISTICS AS` `TRANSACTION ISOLATION LEVEL` ...	BigQuery verwendet immer die Snapshot-Isolation. Weitere Informationen finden Sie unter Konsistenzgarantien und Transaktionsisolation.	Definieren Sie die Transaktionsisolationslevel.
`BEGIN TRANSACTION` `END TRANSACTION` `COMMIT`	BigQuery verwendet immer die Snapshot-Isolation. Weitere Informationen finden Sie unter Konsistenzgarantien und Transaktionsisolation.	Definieren Sie die Transaktionsgrenze für Anfragen mit mehreren Anweisungen.
`EXPLAIN` ...	Nicht unterstützt. Ähnliche Funktionen im Abfrageplan und in der Zeitachse	Abfrageplan für eine `SELECT`-Anweisung anzeigen lassen
Nutzeransichten-Metadaten Systemansichten-Metadaten	`SELECT` `* EXCEPT(is_typed)` `FROM` `mydataset.INFORMATION_SCHEMA.TABLES;` BigQueryInformationsschema	Objekte in der Datenbank abfragen

Konsistenzgarantien und Transaktionsisolation

Sowohl Teradata als auch BigQuery sind unteilbar, d. h. ACID-konform auf Mutationsebene über viele Zeilen hinweg. Beispiel: Ein MERGE-Vorgang ist vollständig atomar, auch mit mehreren eingefügten Werten.

Transaktionen

Netezza akzeptiert syntaktisch alle vier Modi der ANSI SQL-Transaktionsisolation. Unabhängig vom angegebenen Modus wird jedoch nur der Modus SERIALIZABLE verwendet, der die höchstmögliche Konsistenzlevel bietet. Dieser Modus vermeidet außerdem schmutzige, nicht wiederholbare und Phantom-Lesevorgänge zwischen gleichzeitigen Transaktionen. Netezza verwendet keine herkömmliche Sperre, um die Konsistenz zu erzwingen. Stattdessen wird die Serialisierungsabhängigkeitsprüfung verwendet, eine Form der optimistischen Gleichzeitigkeitserkennung, mit der automatisch ein Rollback der letzten Transaktion durchgeführt wird, wenn zwei Transaktionen versuchen, dieselben Daten zu ändern.

BigQuery unterstützt auch Transaktionen. BigQuery sorgt mit der Snapshot-Isolation für eine optimistische Nebenläufigkeitserkennung (der erste Commit hat Vorrang), bei der eine Abfrage die letzten übergebenen Daten liest, bevor die Abfrage beginnt. Dieser Ansatz sorgt für die gleiche Konsistenz auf Zeilen- und Mutationsbasis sowie zeilenübergreifend innerhalb derselben DML-Anweisung, vermeidet dabei jedoch Deadlocks. Bei mehreren DML-Aktualisierungen für dieselbe Tabelle wechselt BigQuery zur pessimistischen Nebenläufigkeitserkennung. Ladejobs können vollständig unabhängig ausgeführt und an Tabellen angefügt werden.

Rollback

Netezza unterstützt die Anweisung ROLLBACK, um die aktuelle Transaktion abzubrechen und alle Änderungen in der Transaktion gemachten rückgängig zu machen.

In BigQuery können Sie die ROLLBACK TRANSACTION-Anweisung verwenden.

Datenbanklimits

Limit	Netezza	BigQuery
Tabellen pro Datenbank	32.000	Uneingeschränkt
Spalten pro Tabelle	1600	10000
Maximale Zeilengröße	64 KB	100 MB
Länge des Spalten- und Tabellennamens	128 Byte	16.384 Unicode-Zeichen
Zeilen pro Tabelle	Unbegrenzt	Unbegrenzt
Maximale Länge von SQL-Anfragen		1 MB (maximale Länge ungelöster Standard-SQL-Abfragen). 12 MB (maximale Länge gelöster Legacy- und Standard-SQL-Abfragen) Streaming: 10 MB (Limit für HTTP-Anfragegröße) 10.000 (maximale Zeilen pro Anfrage)
Maximale Anfrage- und Antwortgröße		10 MB (Anfrage) und 10 GB (Antwort) oder praktisch unbegrenzt, wenn Sie den Seitenumbruch oder die Cloud Storage API verwenden.
Maximale Anzahl gleichzeitiger Sitzungen	63 gleichzeitige Lese-Schreib-Transaktionen. 2.000 gleichzeitige Verbindungen zum Server.	100 gleichzeitige Abfragen (kann mit einer Slot-Reservierung erhöht werden), 300 gleichzeitige API-Anfragen pro Nutzer

Nächste Schritte

Schritt-für-Schritt-Anleitung zum Migrieren von IBM Netezza zu BigQuery

Anleitung zur IBM Netezza-SQL-Übersetzung

Datentypen

Formatierung von Zeitstempel und Datumstyp

SELECT-Anweisung

Vergleichsoperator

Integrierte SQL-Funktionen

Funktionen

Aggregatfunktionen

Analysefunktionen

Funktionen für Datum und Uhrzeit

Stringfunktionen

Mathematische Funktionen:

DML-Syntax

INSERT-Anweisung

UPDATE-Anweisung

DELETE- und TRUNCATE-Anweisungen

MERGE-Anweisung

DDL-Syntax

CREATE TABLE-Anweisung

DROP-Anweisung

Optionen und Attribute für Spalten

Temporäre Tabellen

Prozedurale SQL-Anweisungen

CREATE PROCEDURE-Anweisung

Variablendeklaration und -zuweisung

Ausnahme-Handler

Dynamische SQL-Anweisungen

Anweisungen zum Kontrollfluss

Andere Aussagen und Elemente der prozeduralen Sprache

Mehrfachanweisungen und mehrzeilige SQL-Anweisungen

Weitere SQL-Anweisungen

Konsistenzgarantien und Transaktionsisolation

Transaktionen

Rollback

Datenbanklimits

Nächste Schritte

`SELECT`-Anweisung

`INSERT`-Anweisung

`UPDATE`-Anweisung

`DELETE`- und `TRUNCATE`-Anweisungen

`MERGE`-Anweisung

`CREATE TABLE`-Anweisung

`DROP`-Anweisung

`CREATE PROCEDURE`-Anweisung