Diese Seite wurde von der Cloud Translation API übersetzt.

Leitfaden zur Übersetzung von IBM Netezza SQL

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
Funktionen

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 Vorabversion 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. In BigQuery sind 9 Ziffern nach dem Dezimalkomma festgelegt, während in Netezza eine benutzerdefinierte Einrichtung möglich ist. In Netezza kann die Genauigkeit `p` zwischen 1 und 38 und die Skalierung `s` zwischen 0 und der Genauigkeit liegen.
`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 Größe des Zeichensatzes 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 Größe des Zeichensatzes 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 korrekt formatiert ist. Das Ausgabeformat zeigt jedoch nicht immer die UTC-Zeitzone an (intern hat BigQuery keine Zeitzone). Das Objekt `DATETIME` im bq-Befehlszeilentool und derGoogle Cloud -Konsole wird gemäß dem RFC 3339 mit einem `T`-Trennzeichen formatiert. In Python und Java JDBC wird jedoch ein Leerzeichen als Trennzeichen verwendet. Verwenden Sie die explizite Funktion `FORMAT_DATETIME`, um das Datumsformat richtig zu 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-SELECT-Anweisung 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`	Weniger 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`	Das aktuelle Datum (Jahr, Monat und Tag) abrufen.
`CURRENT_TIME`	`CURRENT_TIME`	Aktuelle Uhrzeit mit Bruchteil abrufen.
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`	Gibt das aktuelle Systemdatum und die aktuelle Systemzeit zurück, auf die nächste volle Sekunde gerundet.
`NOW`	`CURRENT_TIMESTAMP`	Ruft das aktuelle Systemdatum und die aktuelle Systemzeit auf die nächste volle Sekunde ab.
`COALESCE(exp, 0)`	`COALESCE(exp, 0)`	Ersetzen Sie `NULL` durch „0“.
`NVL(exp, 0)`	`IFNULL(exp, 0)`	Ersetzen Sie `NULL` durch „0“.
`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)`	Strings verketten

Funktionen

In diesem Abschnitt werden Netezza- und BigQuery-Funktionen 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 wird 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 `INSERT`-Anweisung 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 INSERT-Anweisung 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 jedoch erforderlich.

Netezza BigQuery

Netezza	BigQuery
UPDATE tbl SET tbl.col1=val1;	Ohne die `WHERE`-Klausel nicht unterstützt. Verwenden Sie eine `WHERE true`-Klausel, um alle Zeilen zu 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;

Ohne die WHERE-Klausel nicht unterstützt. Verwenden Sie eine WHERE true-Klausel, um alle Zeilen zu 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 UPDATE-Beispiele.

Aufgrund von DML-Kontingenten empfehlen wir, größere MERGE-Anweisungen anstelle mehrerer einzelner UPDATE- und INSERT-Anweisungen zu verwenden. 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 TRUNCATE-Anweisung hat dieselbe Wirkung wie die DELETE-Anweisung, ist aber für große Tabellen viel schneller als die DELETE-Anweisung. Die TRUNCATE-Anweisung wird in Netezza, aber nicht in BigQuery unterstützt. Sie können DELETE-Anweisungen jedoch 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 WHERE-Klausel 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;	Wenn in Netezza eine DELETE-Anweisung ausgeführt wird, werden 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`		In Netezza wird der Befehl `GROOM TABLE` verwendet, um Speicherplatz freizugeben, indem zum Löschen markierte Zeilen entfernt werden.

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;

Wenn in Netezza eine DELETE-Anweisung ausgeführt wird, werden 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 In Netezza wird der Befehl GROOM TABLE verwendet, um Speicherplatz freizugeben, indem zum Löschen markierte Zeilen entfernt werden.

`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 unter BigQuery-MERGE-Beispiele und Netezza-MERGE-Beispiele.

DDL-Syntax

In diesem Abschnitt wird die DDL-Syntax von Netezza und BigQuery 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 beim Erstellen der Tabelle ein Ablaufdatum festlegen. Beispiel für drei Tage: `CREATE TABLE` `'my-project.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. Dies 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. Bei geclusterten Basistabellen (Clustered Base Tables, CBT) von Netezza haben alle Clustering-Spalten 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	Geben Sie eine Spaltenbeschränkung an.
`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 der Dauer 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 Tabellennamenprä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));
```
Beginnen Sie mit dem Lesen und Schreiben aus der temporären Tabelle.

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

Hinweis: 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 Postgres PL/pgSQL-Sprache. 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

Sowohl Netezza als auch BigQuery unterstützen das Erstellen gespeicherter Prozeduren mit 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 Variablen einen Wert zu.

Ausnahmebehandlung

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

Netezza	BigQuery	Beschreibung
`EXCEPTION`	Nicht unterstützt	Deklarieren Sie einen SQL-Ausnahmehandler 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 Control `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 Steuerung `LOOP stmts END LOOP;`	`LOOP` `sql_statement_list END LOOP;`	Loop-Block von Anweisungen.
`EXIT WHEN`	`BREAK`	Eine Prozedur beenden
`WHILE condition LOOP`	`WHILE` Bedingung `DO ...` `END WHILE`	Führen Sie eine Schleife von Anweisungen aus, bis eine while-Bedingung fehlschlägt.

Andere Anweisungen und prozedurale Sprachelemente

Netezza	BigQuery	Beschreibung
`CALL` `proc(param,...)`	Nicht unterstützt	Führen Sie eine Prozedur aus.
`EXEC` `proc(param,...)`	Nicht unterstützt	Führen Sie eine Prozedur aus.
`EXECUTE` `proc(param,...)`	Nicht unterstützt	Führen Sie eine Prozedur 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.

Andere 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 Benutzeroberfläche 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)`	Anzahl der individuellen 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.
Nutzeransichten-Metadaten Systemansichten-Metadaten	`SELECT` `* EXCEPT(is_typed)` `FROM` `mydataset.INFORMATION_SCHEMA.TABLES;` BigQuery Informationsschema	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. Zum Beispiel ist ein MERGE-Vorgang vollständig unteilbar, auch wenn mehrere eingefügte Werte vorhanden sind.

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. In diesem Modus werden auch Dirty Reads, nicht wiederholbare Lesevorgänge und Phantom Reads zwischen gleichzeitigen Transaktionen vermieden. Netezza verwendet keine herkömmliche Sperrung, um die Konsistenz zu erzwingen. Stattdessen wird die Prüfung der Serialisierungsabhängigkeit verwendet, eine Form der optimistischen Gleichzeitigkeitserkennung, um die letzte Transaktion automatisch zurückzusetzen, 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österLegacy- 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-/Schreibtransaktionen. 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

Leitfaden zur Übersetzung von IBM Netezza SQL

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

Ausnahmebehandlung

Dynamische SQL-Anweisungen

Anweisungen zum Kontrollfluss

Andere Anweisungen und prozedurale Sprachelemente

Mehrfachanweisungen und mehrzeilige SQL-Anweisungen

Andere 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