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 nach dem Dezimalpunkt 9 Ziffern festgelegt, während Netezza eine benutzerdefinierte Einrichtung zulässt. In Netezza kann die Genauigkeit `p` zwischen 1 und 38 liegen und die Skalierung `s` zwischen 0 und der Genauigkeit.
`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 für `n` in `CHAR(n)` ist 1. Die maximale Größe eines Zeichenstrings 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 eines Zeichenstrings 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 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. 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`	In BigQuery werden keine arithmetischen Datenoperationen unterstützt. Nutzen Sie stattdessen die `DATE_ADD`-Funktion.

`SELECT`-Anweisung

Die Netezza-SELECT-Anweisung ist in der Regel 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`	Rufen Sie das aktuelle Datum (Jahr, Monat und Tag) ab.
`CURRENT_TIME`	`CURRENT_TIME`	Ermitteln Sie die aktuelle Uhrzeit mit Anteil.
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`	Das aktuelle Systemdatum und die aktuelle Systemzeit, auf die nächste volle Sekunde genau.
`NOW`	`CURRENT_TIMESTAMP`	Ruft das aktuelle Systemdatum und die aktuelle Systemzeit auf, auf die nächste volle Sekunde genau.
`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)`	Verketten Sie Strings.

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 mit der von 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 zulässig, 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 zulässig, 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. Außerdem bietet BigQuery keine anderen Einschränkungen als NOT NULL.

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;	Wird ohne die Klausel `WHERE` 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;

Wird ohne die Klausel WHERE 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 der DML-Kontingente 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 den gleichen Effekt wie die DELETE-Anweisung, ist jedoch viel schneller als die DELETE-Anweisung für große Tabellen. Die Anweisung TRUNCATE 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 Klausel WHERE 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 Löschanweisung 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`		Netezza verwendet den Befehl `GROOM TABLE`, um Speicherplatz freizugeben, indem er zum Löschen markierte Zeilen entfernt.

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 Löschanweisung 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 Netezza verwendet den Befehl GROOM TABLE, um Speicherplatz freizugeben, indem er zum Löschen markierte Zeilen entfernt.

`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 mit der von 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 deren Ablauf bei der Erstellung angeben. 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.	Schnelle Suche 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. Geclusterte Basistabellen von Netezza (CBT) bieten jeder Clustering-Spalte dieselbe 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 die Spalteneinschrä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 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));
```
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.

Beachten Sie, dass BigQuery die Spalten DEFAULT und IDENTITY (Sequenzen) nicht unterstützt.

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 beide das Erstellen gespeicherter Prozeduren mithilfe der CREATE PROCEDURE-Anweisung. Weitere Informationen finden Sie unter Mit SQL-gespeicherten Prozeduren arbeiten.

Variablendeklaration und -zuweisung

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

Ausnahmebehandlung

Netezza unterstützt Ausnahme-Handler, die bei bestimmten Fehlerbedingungen ausgelöst werden können. In BigQuery werden keine Bedingungshandler unterstützt.

Netezza	BigQuery	Beschreibung
`EXCEPTION`	Nicht unterstützt	Deklarieren Sie einen 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 Steuerung `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`	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,` oder 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)`	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
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 Transaktionsisolation von ANSI SQL. 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 phantomische Lesevorgänge zwischen gleichzeitigen Transaktionen. Netezza verwendet keine herkömmliche Sperren, um Konsistenz zu erzwingen. Stattdessen wird die Überprüfung von Serialization Dependencies verwendet, eine Form der optimistischen Gleichzeitigkeitssteuerung, um die letzte Transaktion automatisch rückgängig zu machen, 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