Panduan penerjemahan SQL IBM Netezza

Data warehousing IBM Netezza dirancang untuk berfungsi dengan sintaksis SQL khusus Netezza. SQL Netezza didasarkan pada Postgres 7.2. Skrip SQL yang ditulis untuk Netezza tidak dapat digunakan di data warehouse BigQuery tanpa perubahan, karena dialek SQL-nya bervariasi.

Dokumen ini menjelaskan persamaan dan perbedaan sintaksis SQL antara Netezza dan BigQuery di area berikut:

Jenis data
Elemen bahasa SQL
Sintaksis kueri
Bahasa manipulasi data (DML)
Bahasa definisi data (DDL)
Prosedur tersimpan
Functions

Anda juga dapat menggunakan batch terjemahan SQL untuk memigrasikan skrip SQL secara massal, atau terjemahan SQL interaktif untuk menerjemahkan ad-hoc kueri. IBM Netezza SQL/NZPLSQL didukung oleh kedua alat di pratinjau.

Jenis data

Netezza	BigQuery	Catatan
`INTEGER/INT/INT4`	`INT64`
`SMALLINT/INT2`	`INT64`
`BYTEINT/INT1`	`INT64`
`BIGINT/INT8`	`INT64`
`DECIMAL`	`NUMERIC`	Jenis data `DECIMAL` di Netezza adalah alias untuk jenis data `NUMERIC`.
`NUMERIC`	`NUMERIC` `INT64`
`NUMERIC(p,s)`	`NUMERIC`	Jenis `NUMERIC` di BigQuery tidak menerapkan digit khusus atau pembatas skala (batasan) sebagaimana Netezza. BigQuery telah menetapkan 9 digit setelah desimal, sedangkan Netezza memungkinkan penyiapan kustom. Di Netezza, presisi `p` dapat berkisar dari 1 hingga 38, dan menskalakan `s` dari 0 hingga presisi.
`FLOAT(p)`	`FLOAT64`
`REAL/FLOAT(6)`	`FLOAT64`
`DOUBLE PRECISION/FLOAT(14)`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	Jenis `STRING` di BigQuery memiliki panjang variabel dan tidak memerlukan penyetelan panjang karakter maksimum secara manual sebagaimana diperlukan oleh jenis Netezza `CHARACTER` dan `VARCHAR`. Nilai default `n` di `CHAR(n)` adalah 1. Ukuran string karakter maksimum adalah 64.000.
`VARCHAR`	`STRING`	Jenis `STRING` di BigQuery memiliki panjang variabel dan tidak memerlukan penyetelan panjang karakter maksimum secara manual sebagaimana diperlukan oleh jenis Netezza `CHARACTER` dan `VARCHAR`. Ukuran string karakter maksimum adalah 64.000.
`NCHAR`	`STRING`	Jenis `STRING` di BigQuery disimpan sebagai Unicode berenkode UTF-8 dengan panjang variabel. Panjang maksimum adalah 16.000 karakter.
`NVARCHAR`	`STRING`	Jenis `STRING` di BigQuery disimpan sebagai Unicode berenkode UTF-8 dengan panjang variabel. Panjang maksimum adalah 16.000 karakter.
`VARBINARY`	`BYTES`
`ST_GEOMETRY`	`GEOGRAPHY`
`BOOLEAN/BOOL`	`BOOL`	Jenis `BOOL` di BigQuery hanya dapat menerima `TRUE/FALSE`, tidak seperti jenis `BOOL` di Netezza, yang dapat menerima berbagai nilai seperti `0/1`, `yes/no`, `true/false,` `on/off`.
`DATE`	`DATE`
`TIME`	`TIME`
`TIMETZ/TIME WITH TIME ZONE`	`TIME`	Netezza menyimpan jenis data `TIME` dalam UTC dan memungkinkan Anda meneruskan offset dari UTC menggunakan sintaksis `WITH TIME ZONE`. Jenis data `TIME` di BigQuery mewakili waktu yang tidak bergantung pada tanggal atau zona waktu mana pun.
`TIMESTAMP`	`DATETIME`	Jenis `TIMESTAMP` Netezza tidak mencakup zona waktu, sama seperti jenis `DATETIME` BigQuery.
	`ARRAY`	Tidak ada jenis data array di Netezza. Jenis array tersebut disimpan di kolom varchar.

Pemformatan jenis tanggal dan stempel waktu

Untuk mengetahui informasi selengkapnya tentang format jenis tanggal yang digunakan Netezza SQL, lihat dokumentasi Pola template Waktu Tanggal Netezza. Untuk mengetahui informasi selengkapnya tentang fungsi tanggal waktu, lihat dokumentasi Fungsi tanggal/waktu Netezza.

Saat mengonversi elemen pemformatan jenis tanggal dari Netezza ke GoogleSQL, Anda harus memberikan perhatian khusus pada perbedaan zona waktu antara TIMESTAMP dan DATETIME, seperti yang diringkas dalam tabel berikut:

Netezza	BigQuery
Informasi `CURRENT_TIMESTAMP` `CURRENT_TIME` `TIME` di Netezza dapat memiliki informasi zona waktu berbeda, yang ditentukan menggunakan sintaksis `WITH TIME ZONE`.	Jika memungkinkan, gunakan fungsi `CURRENT_TIMESTAMP`, yang diformat dengan benar. Namun, format output tidak selalu menampilkan zona waktu UTC (secara internal, BigQuery tidak memiliki zona waktu). Objek `DATETIME` dalam alat command line bq dan konsol Google Cloud diformat menggunakan pemisah `T` sesuai dengan RFC 3339. Namun, dalam Python dan Java JDBC, spasi digunakan sebagai pemisah. Gunakan fungsi `FORMAT_DATETIME` eksplisit untuk menentukan format tanggal dengan benar. Jika tidak, transmisi eksplisit akan dibuat pada string, misalnya: `CAST(CURRENT_DATETIME() AS STRING)` Tindakan ini juga menampilkan pemisah spasi singkat ini.
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_DATE-3`	BigQuery tidak mendukung operasi data aritmatika. Sebagai gantinya, gunakan fungsi `DATE_ADD`.

Pernyataan `SELECT`

Secara umum, pernyataan SELECT Netezza kompatibel dengan BigQuery. Tabel berikut berisi daftar pengecualian:

Netezza BigQuery

Netezza	BigQuery
Pernyataan `SELECT` tanpa klausa `FROM`	Mendukung kasus khusus seperti berikut: `SELECT 1 UNION ALL SELECT 2;`
SELECT (subquery) AS flag, CASE WHEN flag = 1 THEN ...	Dalam BigQuery, kolom tidak dapat mereferensikan output kolom lain yang ditentukan di dalam kueri yang sama. Anda harus menduplikasi logika atau memindahkan logika ke dalam kueri bertingkat. Opsi 1 SELECT (subquery) AS flag, CASE WHEN (subquery) = 1 THEN ... Opsi 2 SELECT q.*, CASE WHEN flag = 1 THEN ... FROM ( SELECT (subquery) AS flag, ... ) AS q

Pernyataan SELECT tanpa klausa FROM

Mendukung kasus khusus seperti berikut:

SELECT 1 UNION ALL SELECT 2;


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

Dalam BigQuery, kolom tidak dapat mereferensikan output kolom lain yang ditentukan di dalam kueri yang sama. Anda harus menduplikasi logika atau memindahkan logika ke dalam kueri bertingkat.

Opsi 1


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

Opsi 2


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

Operator perbandingan

Netezza	BigQuery	Deskripsi
`exp = exp2`	`exp = exp2`	Sama dengan
`exp <= exp2`	`exp <= exp2`	Kurang dari atau sama dengan
`exp < exp2`	`exp < exp2`	Kurang dari
`exp <> exp2` `exp != exp2`	`exp <> exp2` `exp != exp2`	Tidak sama dengan
`exp >= exp2`	`exp >= exp2`	Lebih dari atau sama dengan
`exp > exp2`	`exp > exp2`	Lebih dari

Fungsi SQL bawaan

Netezza	BigQuery	Deskripsi
`CURRENT_DATE`	`CURRENT_DATE`	Mendapatkan tanggal saat ini (tahun, bulan, dan hari).
`CURRENT_TIME`	`CURRENT_TIME`	Dapatkan waktu saat ini dengan bilangan pecahan.
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`	Mendapatkan tanggal dan waktu sistem saat ini, hingga detik penuh terdekat.
`NOW`	`CURRENT_TIMESTAMP`	Mendapatkan tanggal dan waktu sistem saat ini, hingga detik penuh terdekat.
`COALESCE(exp, 0)`	`COALESCE(exp, 0)`	Mengganti `NULL` dengan nol.
`NVL(exp, 0)`	`IFNULL(exp, 0)`	Mengganti `NULL` dengan nol.
`EXTRACT(DOY FROM timestamp_expression)`	`EXTRACT(DAYOFYEAR FROM timestamp_expression)`	Menampilkan jumlah hari dari awal tahun.
`ADD_MONTHS(date_expr, num_expr)`	`DATE_ADD(date, INTERVAL k MONTH)`	Menambahkan bulan ke tanggal.
`DURATION_ADD(date, k)`	`DATE_ADD(date, INTERVAL k DAY)`	Melakukan penambahan pada tanggal.
`DURATION_SUBTRACT(date, k)`	`DATE_SUB(date, INTERVAL k DAY)`	Melakukan pengurangan pada tanggal.
`str1 \|\| str2`	`CONCAT(str1, str2)`	Menggabungkan string.

Functions

Bagian ini membandingkan fungsi Netezza dan BigQuery.

Fungsi agregat

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

Fungsi analisis

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`	Operator bukan bitwise: `~`
`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`

Fungsi tanggal dan waktu

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`

Fungsi string

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`

Fungsi matematika

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

Sintaksis DML

Bagian ini membandingkan sintaks Netezza dan BigQuery DML.

Pernyataan `INSERT`

Netezza BigQuery

Netezza	BigQuery
INSERT INTO table VALUES (...);	INSERT INTO table (...) VALUES (...); Netezza menawarkan kata kunci `DEFAULT` dan batasan lainnya untuk kolom. Di BigQuery, menghilangkan nama kolom dalam pernyataan `INSERT` hanya valid jika semua kolom diberikan.
INSERT INTO table (...) VALUES (...); INSERT INTO table (...) VALUES (...);	INSERT INTO table VALUES (), (); BigQuery menerapkan kuota DML, yang membatasi jumlah pernyataan DML yang dapat Anda jalankan setiap hari. Untuk memanfaatkan kuota sebaik mungkin, pertimbangkan pendekatan berikut: Menggabungkan beberapa baris dalam satu pernyataan `INSERT`, bukan satu baris per pernyataan `INSERT`. Menggabungkan beberapa pernyataan DML (termasuk pernyataan `INSERT`) menggunakan pernyataan `MERGE`. Menggunakan pernyataan `CREATE TABLE ... AS SELECT` untuk membuat dan mengisi tabel baru.


INSERT INTO table VALUES (...);


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

Netezza menawarkan kata kunci DEFAULT dan batasan lainnya untuk kolom. Di BigQuery, menghilangkan nama kolom dalam pernyataan INSERT hanya valid jika semua kolom diberikan.


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


INSERT INTO table VALUES (), ();

BigQuery menerapkan kuota DML, yang membatasi jumlah pernyataan DML yang dapat Anda jalankan setiap hari. Untuk memanfaatkan kuota sebaik mungkin, pertimbangkan pendekatan berikut:

Menggabungkan beberapa baris dalam satu pernyataan INSERT, bukan satu baris per pernyataan INSERT.

Menggabungkan beberapa pernyataan DML (termasuk pernyataan INSERT) menggunakan pernyataan MERGE.

Menggunakan pernyataan CREATE TABLE ... AS SELECT untuk membuat dan mengisi tabel baru.

Skrip DML di BigQuery memiliki semantik konsistensi yang sedikit berbeda dengan pernyataan yang setara di Netezza. Perlu diperhatikan juga bahwa BigQuery tidak menawarkan batasan selain NOT NULL.

Untuk ringkasan tentang snapshot isolation serta penanganan sesi dan transaksi, lihat Jaminan konsistensi dan transaction isolation.

Pernyataan `UPDATE`

Di Netezza, klausa WHERE bersifat opsional, tetapi diperlukan di BigQuery.

Netezza BigQuery

Netezza	BigQuery
UPDATE tbl SET tbl.col1=val1;	Tidak didukung tanpa klausa `WHERE`. Gunakan klausa `WHERE true` untuk memperbarui semua baris.
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;

Tidak didukung tanpa klausa WHERE. Gunakan klausa WHERE true untuk memperbarui semua baris.


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;

Untuk contoh, lihat contoh UPDATE.

Karena kuota DML, sebaiknya gunakan pernyataan MERGE yang lebih besar, bukan beberapa pernyataan UPDATE dan INSERT tunggal. Skrip DML di BigQuery memiliki semantik konsistensi yang sedikit berbeda dengan pernyataan yang setara di Netezza. Untuk ringkasan tentang snapshot isolation serta penanganan sesi dan transaksi, lihat Jaminan konsistensi dan transaction isolation.

Pernyataan `DELETE` dan `TRUNCATE`

Pernyataan DELETE dan TRUNCATE adalah cara untuk menghapus baris dari tabel tanpa memengaruhi skema atau indeks tabel. Pernyataan TRUNCATE memiliki efek yang sama dengan pernyataan DELETE tetapi jauh lebih cepat daripada pernyataan DELETE untuk tabel besar. Pernyataan TRUNCATE didukung di Netezza, tetapi tidak didukung di BigQuery. Namun, Anda dapat menggunakan pernyataan DELETE di Netezza dan BigQuery.

Di BigQuery, pernyataan DELETE harus memiliki klausa WHERE. Di Netezza, klausa WHERE bersifat opsional. Jika klausa WHERE tidak ditentukan, semua baris dalam tabel Netezza akan dihapus.

Netezza BigQuery Deskripsi

Netezza	BigQuery	Deskripsi
BEGIN; LOCK TABLE A IN EXCLUSIVE MODE; DELETE FROM A; INSERT INTO A SELECT * FROM B; COMMIT;	Mengganti isi tabel dengan output kueri sama dengan mengganti transaksi. Anda dapat melakukannya dengan operasi `query` atau operasi salinan (`cp`). bq query \ --replace \ --destination_table \ tableA \ 'SELECT * \ FROM tableB \ WHERE ...' bq cp \ -f tableA tableB	Ganti isi tabel dengan hasil kueri.
DELETE FROM database.table	DELETE FROM table WHERE TRUE;	Di Netezza, saat pernyataan hapus dijalankan, baris tidak akan dihapus secara fisik, tetapi hanya ditandai untuk dihapus. Menjalankan perintah `GROOM TABLE` atau `nzreclaim` nantinya akan menghapus baris yang ditandai untuk dihapus dan mengeklaim kembali kapasitas disk yang sesuai.
`GROOM TABLE`		Netezza menggunakan perintah `GROOM TABLE` untuk mendapatkan kembali kapasitas disk dengan menghapus baris yang ditandai untuk dihapus.


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

Mengganti isi tabel dengan output kueri sama dengan mengganti transaksi. Anda dapat melakukannya dengan operasi query atau operasi salinan (cp).


bq query \

--replace \

--destination_table \

tableA \

'SELECT * \

FROM tableB \

WHERE ...'


bq cp \

-f tableA tableB

Ganti isi tabel dengan hasil kueri.


DELETE FROM database.table


DELETE FROM table WHERE TRUE;

Di Netezza, saat pernyataan hapus dijalankan, baris tidak akan dihapus secara fisik, tetapi hanya ditandai untuk dihapus. Menjalankan perintah GROOM TABLE atau nzreclaim nantinya akan menghapus baris yang ditandai untuk dihapus dan mengeklaim kembali kapasitas disk yang sesuai.

GROOM TABLE Netezza menggunakan perintah GROOM TABLE untuk mendapatkan kembali kapasitas disk dengan menghapus baris yang ditandai untuk dihapus.

Pernyataan `MERGE`

Pernyataan MERGE harus cocok dengan maksimal satu baris sumber untuk setiap baris target. Skrip ML di BigQuery memiliki semantik konsistensi yang sedikit berbeda dari pernyataan setara di Netezza. Untuk ringkasan snapshot isolation serta penanganan sesi dan transaksi, lihat Jaminan konsistensi dan transaction isolation. Misalnya, lihat contoh MERGE BigQuery dan contoh MERGE Netezza.

Sintaksis DDL

Bagian ini membandingkan sintaks DDL Netezza dan BigQuery.

Pernyataan `CREATE TABLE`

Netezza	BigQuery	Deskripsi
`TEMP` `TEMPORARY`	Dengan dukungan DDL BigQuery, Anda dapat membuat tabel dari hasil kueri dan menentukan masa habis berlaku dan pembuatannya. Misalnya, selama tiga hari: `CREATE TABLE` `'fh-bigquery.public_dump.vtemp'` `OPTIONS`( `expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(),` `INTERVAL 3 DAY))`	Buat tabel sementara untuk satu sesi.
`ZONE MAPS`	Tidak didukung.	Penelusuran cepat untuk kondisi `WHERE`.
`DISTRIBUTE ON`	`PARTITION BY`	Membuat partisi. Ini bukan terjemahan langsung. `DISTRIBUTE ON` berbagi data antar-node, biasanya dengan kunci unik untuk distribusi merata, sedangkan `PARTITION BY` memangkas data menjadi beberapa segmen.
`ORGANIZE ON`	`CLUSTER BY`	Netezza dan BigQuery mendukung hingga empat kunci untuk pengelompokan. Clustered base table (CBT) Netezza memberikan prioritas yang sama untuk setiap kolom pengelompokan. BigQuery memberikan prioritas pada kolom pertama tempat tabel dikelompokkan, diikuti dengan kolom kedua, dan seterusnya.
`ROW SECURITY`	`Authorized View`	Keamanan tingkat baris.
`CONSTRAINT`	Tidak didukung	Check batasan.

Pernyataan `DROP`

Netezza	BigQuery	Deskripsi
`DROP TABLE`	`DROP TABLE`
`DROP DATABASE`	`DROP DATABASE`
`DROP VIEW`	`DROP VIEW`

Opsi dan atribut kolom

Netezza	BigQuery	Deskripsi
`NULL` `NOT NULL`	`NULLABLE` `REQUIRED`	Tentukan apakah kolom diizinkan untuk berisi nilai `NULL`.
`REFERENCES`	Tidak didukung	Tentukan batasan kolom.
`UNIQUE`	Tidak didukung	Setiap nilai dalam kolom harus unik.
`DEFAULT`	Tidak didukung	Nilai default untuk semua nilai dalam kolom.

Tabel sementara

Netezza mendukung tabel TEMPORARY yang ada selama durasi sesi.

Untuk membuat tabel sementara di BigQuery, lakukan hal berikut:

Buat set data yang memiliki masa aktif singkat (misalnya, 12 jam).
Buat tabel sementara dalam set data tersebut, dengan awalan nama tabel temp. Misalnya, untuk membuat tabel yang akan habis masa berlakunya dalam satu jam, lakukan hal berikut:
```
CREATE TABLE temp.name (col1, col2, ...)
OPTIONS(expiration_timestamp = TIMESTAMP_ADD(CURRENT_TIMESTAMP(),
INTERVAL 1 HOUR));
```
Mulailah membaca dan menulis dari tabel sementara.

Anda juga dapat menghapus duplikat secara independen untuk menemukan error dalam sistem downstream.

Perhatikan bahwa BigQuery tidak mendukung kolom (urutan) DEFAULT and IDENTITY.

Pernyataan SQL prosedural

Netezza menggunakan bahasa skrip NZPLSQL untuk menangani prosedur yang tersimpan. NZPLSQL didasarkan pada bahasa PL/pgSQL Postgres. Bagian ini menjelaskan cara mengonversi pernyataan SQL prosedural yang digunakan dalam prosedur, fungsi, dan pemicu tersimpan dari Netezza ke BigQuery.

Pernyataan `CREATE PROCEDURE`

Netezza dan BigQuery mendukung pembuatan prosedur tersimpan dengan menggunakan pernyataan CREATE PROCEDURE. Untuk mengetahui informasi selengkapnya, lihat Menggunakan prosedur tersimpan SQL.

Deklarasi dan penetapan variabel

Netezza	BigQuery	Deskripsi
`DECLARE var datatype(len) [DEFAULT value];`	`DECLARE`	Mendeklarasikan variabel.
`SET var = value;`	`SET`	Menetapkan nilai ke variabel.

Pengendali pengecualian

Netezza mendukung pengendali pengecualian yang dapat dipicu untuk kondisi error tertentu. BigQuery tidak mendukung pengendali kondisi.

Netezza	BigQuery	Deskripsi
`EXCEPTION`	Tidak didukung	Mendeklarasikan pengendali pengecualian SQL untuk error umum.

Pernyataan SQL dinamis

Netezza mendukung kueri SQL dinamis di dalam prosedur yang tersimpan. BigQuery tidak mendukung pernyataan SQL dinamis.

Netezza	BigQuery	Deskripsi
`EXECUTE IMMEDIATE` `sql_str;`	`EXECUTE IMMEDIATE` `sql_str;`	Menjalankan SQL dinamis.

Pernyataan flow-of-control

Netezza	BigQuery	Deskripsi
`IF THEN ELSE STATEMENT` `IF` kondisi `THEN ...` `ELSE ...` `END IF;`	`IF` kondisi `THEN ...` `ELSE ...` `END IF;`	Jalankan dengan kondisi.
Kontrol Iteratif `FOR var AS SELECT ...` `DO` stmts `END FOR;` `FOR var AS cur CURSOR` `FOR SELECT ...` `DO stmts END FOR;`	Tidak didukung	Melakukan iterasi pada kumpulan baris.
Kontrol Iteratif `LOOP stmts END LOOP;`	`LOOP` `sql_statement_list END LOOP;`	Blok pernyataan loop.
`EXIT WHEN`	`BREAK`	Keluar dari prosedur.
`WHILE condition LOOP`	`WHILE` kondisi `DO ...` `END WHILE`	Menalankan loop pernyataan sampai kondisi while gagal.

Pernyataan dan elemen bahasa prosedural lainnya

Netezza	BigQuery	Deskripsi
`CALL` `proc(param,...)`	Tidak didukung	Menjalankan prosedur.
`EXEC` `proc(param,...)`	Tidak didukung	Menjalankan prosedur.
`EXECUTE` `proc(param,...)`	Tidak didukung	Menjalankan prosedur.

Pernyataan SQL multi-pernyataan dan multi-baris

Netezza dan BigQuery mendukung transaksi (sesi) dan oleh karena itu, mendukung pernyataan yang dipisahkan dengan titik koma yang dijalankan bersama dengan konsisten. Untuk informasi selengkapnya, lihat Transaksi multi-pernyataan.

Pernyataan SQL lainnya

Netezza	BigQuery	Deskripsi
`GENERATE STATISTICS`		Membuat statistik untuk semua tabel dalam database saat ini.
`GENERATE STATISTICS ON table_name`		Membuat statistik untuk tabel tertentu.
`GENERATE STATISTICS ON table_name(col1,col4)`	Gunakan fungsi statistik seperti `MIN, MAX, AVG,` dll., gunakan UI, atau gunakan Cloud Data Loss Prevention API.	Membuat statistik untuk kolom tertentu dalam tabel.
`GENERATE STATISTICS ON table_name`	`APPROX_COUNT_DISTINCT(col)`	Menampilkan jumlah nilai unik untuk kolom.
`INSERT INTO table_name`	`INSERT INTO table_name`	Menyisipkan baris.
`LOCK TABLE` `table_name FOR` `EXCLUSIVE;`	Tidak didukung	Mengunci baris.
`SET SESSION` `CHARACTERISTICS AS` `TRANSACTION ISOLATION LEVEL` ...	BigQuery selalu menggunakan Dnapshot Isolation. Untuk mengetahui detailnya, lihat Jaminan konsistensi dan transaction isolation.	Tentukan tingkat transaction isolation.
`BEGIN TRANSACTION` `END TRANSACTION` `COMMIT`	BigQuery selalu menggunakan Dnapshot Isolation. Untuk mengetahui detailnya, lihat Jaminan konsistensi dan transaction isolation.	Tentukan batas transaksi untuk permintaan multi-pernyataan.
`EXPLAIN` ...	Tidak didukung. Fitur serupa di kueri dan linimasa rencana	Tampilkan rencana kueri untuk pernyataan `SELECT`.
Metadata Tampilan Pengguna Metadata Tampilan Sistem	`SELECT` `* EXCEPT(is_typed)` `FROM` `mydataset.INFORMATION_SCHEMA.TABLES;` BigQuery Skema Informasi	Membuat kueri objek dalam database

Jaminan konsistensi dan transaction isolation

Netezza dan BigQuery bersifat atomik, yaitu sesuai dengan ACID pada tingkat per mutasi di banyak baris. Misalnya, operasi MERGE sepenuhnya atomik, bahkan dengan beberapa nilai yang disisipkan.

Transaksi

Netezza secara sintaksis menerima keempat mode transaction isolation ANSI SQL. Namun, terlepas dari mode yang ditentukan, hanya mode SERIALIZABLE yang digunakan, yang memberikan tingkat konsistensi setinggi mungkin. Mode ini juga menghindari pembacaan kotor, tidak dapat diulang, dan phantom di antara transaksi konkurensi. Netezza tidak menggunakan penguncian konvensional untuk menerapkan konsistensi. Sebagai gantinya, metode ini menggunakan pemeriksaan dependensi serialisasi, yaitu bentuk kontrol konkurensi optimis untuk melakukan roll back transaksi terbaru otomatis saat dua transaksi mencoba mengubah data yang sama.

BigQuery juga mendukung transaksi. BigQuery membantu memastikan kontrol konkurensi optimis (yang pertama kali di-commit akan memiliki prioritas) dengan snapshot isolation, serta kueri membaca data yang di-commit terakhir sebelum kueri dimulai. Pendekatan ini menjamin tingkat konsistensi yang sama per baris, per mutasi, dan di seluruh baris dalam pernyataan DML yang sama, sembari menghindari deadlock. Dalam kasus beberapa update DML terhadap tabel yang sama, BigQuery akan beralih ke kontrol konkurensi pesimis. Tugas pemuatan dapat berjalan sepenuhnya secara independen dan ditambahkan ke tabel.

Rollback

Netezza mendukung pernyataan ROLLBACK untuk membatalkan transaksi saat ini dan melakukan roll back pada semua perubahan yang dibuat dalam transaksi.

Di BigQuery, Anda dapat menggunakan pernyataan ROLLBACK TRANSACTION.

Batas database

Batas	Netezza	BigQuery
Tabel per database	32.000	Tidak dibatasi
Kolom per tabel	1600	10000
Ukuran baris maksimum	64 KB	100 MB
Panjang kolom dan nama tabel	128 byte	16.384 karakter Unicode
Baris per tabel	Tak terbatas	Tak terbatas
Panjang permintaan SQL maksimum		1 MB (panjang kueri SQL standar maksimum yang belum terselesaikan). 12 MB (panjang maksimum kueri SQL lama dan standar yang diselesaikan). Streaming: 10 MB (batas ukuran permintaan HTTP) 10.000 (baris maksimum per permintaan)
Ukuran permintaan dan respons maksimum		10 MB (permintaan) dan 10 GB (respons) atau hampir tidak terbatas jika menggunakan penomoran halaman atau Cloud Storage API.
Jumlah maksimum sesi serentak	63 transaksi baca-tulis serentak. 2.000 koneksi serentak ke server.	100 kueri serentak (dapat diajukan dengan pemesanan slot), 300 permintaan API serentak per pengguna.

Langkah selanjutnya

Dapatkan petunjuk langkah demi langkah untuk Bermigrasi dari IBM Netezza ke BigQuery.

Panduan penerjemahan SQL IBM Netezza

Jenis data

Pemformatan jenis tanggal dan stempel waktu

Pernyataan SELECT

Operator perbandingan

Fungsi SQL bawaan

Functions

Fungsi agregat

Fungsi analisis

Fungsi tanggal dan waktu

Fungsi string

Fungsi matematika

Sintaksis DML

Pernyataan INSERT

Pernyataan UPDATE

Pernyataan DELETE dan TRUNCATE

Pernyataan MERGE

Sintaksis DDL

Pernyataan CREATE TABLE

Pernyataan DROP

Opsi dan atribut kolom

Tabel sementara

Pernyataan SQL prosedural

Pernyataan CREATE PROCEDURE

Deklarasi dan penetapan variabel

Pengendali pengecualian

Pernyataan SQL dinamis

Pernyataan flow-of-control

Pernyataan dan elemen bahasa prosedural lainnya

Pernyataan SQL multi-pernyataan dan multi-baris

Pernyataan SQL lainnya

Jaminan konsistensi dan transaction isolation

Transaksi

Rollback

Batas database

Langkah selanjutnya

Pernyataan `SELECT`

Pernyataan `INSERT`

Pernyataan `UPDATE`

Pernyataan `DELETE` dan `TRUNCATE`

Pernyataan `MERGE`

Pernyataan `CREATE TABLE`

Pernyataan `DROP`

Pernyataan `CREATE PROCEDURE`