Halaman ini diterjemahkan oleh Cloud Translation API.

Panduan penerjemahan SQL Teradata

Dokumen ini menjelaskan persamaan dan perbedaan sintaksis SQL antara Teradata dan BigQuery untuk membantu Anda merencanakan migrasi. Gunakan terjemahan SQL batch untuk memigrasikan skrip SQL secara massal, atau terjemahan SQL interaktif untuk menerjemahkan kueri ad hoc.

Jenis data

Bagian ini menunjukkan padanan di antara jenis data di Teradata dan di BigQuery.

Teradata	BigQuery	Catatan
`INTEGER`	`INT64`
`SMALLINT`	`INT64`
`BYTEINT`	`INT64`
`BIGINT`	`INT64`
`DECIMAL`	`NUMERIC, DECIMAL` `BIGNUMERIC, BIGDECIMAL`	Gunakan `NUMERIC` BigQuery (alias `DECIMAL`) jika skala (angka setelah titik desimal) <= 9. Gunakan `BIGNUMERIC` BigQuery (alias `BIGDECIMAL`) jika skala > 9. Gunakan jenis data desimal berparameter BigQuery jika Anda perlu menerapkan batas (batasan) digit atau skala kustom. Teradata memungkinkan Anda menyisipkan nilai dengan presisi yang lebih tinggi dengan membulatkan nilai yang disimpan; namun, hal ini mempertahankan presisi tinggi dalam penghitungan. Hal ini dapat menyebabkan perilaku pembulatan yang tidak terduga dibandingkan dengan standar ANSI.
`FLOAT`	`FLOAT64`
`NUMERIC`	`NUMERIC, DECIMAL` `BIGNUMERIC, BIGDECIMAL`	Gunakan `NUMERIC` BigQuery (alias `DECIMAL`) jika skala (angka setelah titik desimal) <= 9. Gunakan `BIGNUMERIC` BigQuery (alias `BIGDECIMAL`) jika skala > 9. Gunakan jenis data desimal berparameter BigQuery jika Anda perlu menerapkan batas (batasan) digit atau skala kustom. Teradata memungkinkan Anda menyisipkan nilai dengan presisi yang lebih tinggi dengan membulatkan nilai yang disimpan; namun, hal ini akan mempertahankan presisi tinggi dalam penghitungan. Hal ini dapat menyebabkan perilaku pembulatan yang tidak terduga dibandingkan dengan standar ANSI.
`NUMBER`	`NUMERIC, DECIMAL` `BIGNUMERIC, BIGDECIMAL`	Gunakan `NUMERIC` BigQuery (alias `DECIMAL`) jika skala (angka setelah titik desimal) <= 9. Gunakan `BIGNUMERIC` BigQuery (alias `BIGDECIMAL`) jika skala > 9. Gunakan jenis data desimal berparameter BigQuery jika Anda perlu menerapkan batas (batasan) digit atau skala kustom. Teradata memungkinkan Anda menyisipkan nilai dengan presisi yang lebih tinggi dengan membulatkan nilai yang disimpan; namun, hal ini akan mempertahankan presisi tinggi dalam penghitungan. Hal ini dapat menyebabkan perilaku pembulatan yang tidak terduga dibandingkan dengan standar ANSI.
`REAL`	`FLOAT64`
`CHAR/CHARACTER`	`STRING`	Gunakan jenis data `STRING` BigQuery yang berparameter jika Anda perlu menerapkan panjang karakter maksimum.
`VARCHAR`	`STRING`	Gunakan jenis data `STRING` BigQuery yang berparameter jika Anda perlu menerapkan panjang karakter maksimum.
`CLOB`	`STRING`
`JSON`	`JSON`
`BLOB`	`BYTES`
`BYTE`	`BYTES`
`VARBYTE`	`BYTES`
`DATE`	`DATE`	BigQuery tidak mendukung pemformatan kustom yang serupa dengan yang didukung Teradata dengan DataForm di SDF.
`TIME`	`TIME`
`TIME WITH TIME ZONE`	`TIME`	Teradata 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`	`TIMESTAMP`	Jenis data Teradata dan BigQuery `TIMESTAMP` memiliki presisi mikrodetik (tetapi Teradata mendukung detik kabisat, sedangkan BigQuery tidak). Jenis data Teradata dan BigQuery biasanya dikaitkan dengan zona waktu UTC (detail).
`TIMESTAMP WITH TIME ZONE`	`TIMESTAMP`	Teradata `TIMESTAMP` dapat ditetapkan ke zona waktu yang berbeda di seluruh sistem, per pengguna atau per kolom (menggunakan `WITH TIME ZONE`). BigQuery `TIMESTAMP` jenis ini mengasumsikan UTC jika Anda tidak secara eksplisit menetapkan zona waktu. Pastikan Anda mengekspor informasi zona waktu dengan benar (jangan menggabungkan nilai `DATE` dan `TIME` tanpa informasi zona waktu) agar BigQuery dapat mengonversinya saat diimpor. Atau pastikan Anda mengonversi informasi zona waktu ke UTC sebelum mengekspor. BigQuery memiliki `DATETIME` untuk abstraksi antara waktu sipil, yang tidak menampilkan zona waktu saat output, dan `TIMESTAMP`, yang merupakan titik waktu akurat yang selalu menunjukkan zona waktu UTC.
`ARRAY`	`ARRAY`
`MULTI-DIMENSIONAL ARRAY`	`ARRAY`	Di BigQuery, gunakan array struct, dengan setiap struct yang berisi kolom jenis `ARRAY` (Untuk mengetahui detailnya, lihat Dokumentasi BigQuery).
`INTERVAL HOUR`	`INT64`
`INTERVAL MINUTE`	`INT64`
`INTERVAL SECOND`	`INT64`
`INTERVAL DAY`	`INT64`
`INTERVAL MONTH`	`INT64`
`INTERVAL YEAR`	`INT64`
`PERIOD(DATE)`	`DATE`, `DATE`	`PERIOD(DATE)` harus dikonversi menjadi dua kolom `DATE` yang berisi tanggal mulai dan tanggal akhir agar dapat digunakan dengan fungsi jendela.
`PERIOD(TIMESTAMP WITH TIME ZONE)`	`TIMESTAMP`, `TIMESTAMP`
`PERIOD(TIMESTAMP)`	`TIMESTAMP`, `TIMESTAMP`
`PERIOD(TIME)`	`TIME`, `TIME`
`PERIOD(TIME WITH TIME ZONE)`	`TIME`, `TIME`
`UDT`	`STRING`
`XML`	`STRING`
`TD_ANYTYPE`	`STRING`

Untuk informasi selengkapnya tentang transmisi jenis, lihat bagian berikutnya.

Pemformatan jenis teradata

Teradata SQL menggunakan sekumpulan format default untuk menampilkan ekspresi dan data kolom, serta untuk konversi di antara jenis data. Misalnya, jenis data PERIOD(DATE) dalam mode INTEGERDATE diformat sebagai YY/MM/DD secara default. Jika memungkinkan, sebaiknya gunakan mode ANSIDATE untuk memastikan kepatuhan ANSI SQL, dan gunakan kesempatan ini untuk menghapus format lama.

Teradata memungkinkan penerapan otomatis format kustom menggunakan klausa FORMAT, tanpa mengubah penyimpanan yang mendasarinya, baik sebagai atribut jenis data saat Anda membuat tabel menggunakan DDL, atau dalam ekspresi turunan. Misalnya, spesifikasi FORMAT 9.99 membulatkan nilai FLOAT apa pun ke dua digit. Di BigQuery, fungsionalitas ini harus dikonversi menggunakan fungsi ROUND().

Fungsionalitas ini memerlukan penanganan kasus ekstrem yang rumit. Misalnya, saat klausa FORMAT diterapkan ke kolom NUMERIC, Anda harus mempertimbangkan aturan pembulatan dan pemformatan khusus. Klausa FORMAT dapat digunakan untuk mentransmisikan nilai epoch INTEGER secara implisit ke format DATE. Atau, spesifikasi FORMAT, X(6) di kolom VARCHAR, akan memotong nilai kolom, sehingga Anda harus melakukan konversi ke fungsi SUBSTR(). Perilaku ini tidak sesuai dengan ANSI SQL. Oleh karena itu, sebaiknya jangan migrasikan format kolom ke BigQuery.

Jika format kolom benar-benar diperlukan, gunakan View atau fungsi yang ditentukan pengguna (UDF).

Untuk mengetahui informasi tentang format default yang digunakan Teradata SQL untuk setiap jenis data, lihat dokumentasi Pemformatan default Teradata.

Pemformatan jenis tanggal dan stempel waktu

Tabel berikut merangkum perbedaan dalam elemen pemformatan stempel waktu dan tanggal antara Teradata SQL dan GoogleSQL.

Format teradata	Deskripsi teradata	BigQuery
`CURRENT_TIMESTAMP CURRENT_TIME`	Informasi `TIME` dan `TIMESTAMP` di Teradata dapat memiliki informasi zona waktu yang berbeda, yang ditentukan menggunakan `WITH TIME ZONE`.	Jika memungkinkan, gunakan `CURRENT_TIMESTAMP()`, yang diformat dalam format ISO. Namun, format output selalu menampilkan zona waktu UTC. (Secara internal, BigQuery tidak memiliki zona waktu.) Perhatikan detail berikut tentang perbedaan dalam format ISO. `DATETIME` diformat berdasarkan konvensi saluran output. Di alat command line BigQuery dan konsol BigQuery, format menggunakan pemisah `T` menurut RFC 3339. Namun, dalam Python dan JDBC Java, spasi digunakan sebagai pemisah. Jika Anda ingin menggunakan format eksplisit, gunakan `FORMAT_DATETIME()`, yang membuat string eksplisit. Misalnya, ekspresi berikut selalu menampilkan pemisah spasi: `CAST(CURRENT_DATETIME() AS STRING)` Teradata mendukung Kata kunci `DEFAULT` di kolom `TIME` untuk menetapkan waktu saat ini (stempel waktu); hal ini tidak digunakan dalam BigQuery.
`CURRENT_DATE`	Tanggal disimpan dalam Teradata sebagai `INT64` menggunakan formula berikut: `(YEAR - 1900) * 10000 + (MONTH * 100) + DAY` Tanggal dapat diformat sebagai bilangan bulat.	BigQuery memiliki format `DATE` terpisah yang selalu menampilkan tanggal dalam format ISO 8601. `DATE_FROM_UNIX_DATE` tidak dapat digunakan karena berbasis tahun 1970. Teradata mendukung kata kunci `DEFAULT` di kolom `DATE` untuk menetapkan tanggal saat ini; ID ini tidak digunakan di BigQuery.
`CURRENT_DATE-3`	Nilai tanggal direpresentasikan sebagai bilangan bulat. Teradata mendukung operator aritmatika untuk jenis tanggal.	Untuk jenis tanggal, gunakan `DATE_ADD()` atau `DATE_SUB()`. BigQuery menggunakan operator aritmatika untuk jenis data: `INT64`, `NUMERIC`, dan `FLOAT64`.
`SYS_CALENDAR.CALENDAR`	Teradata menyediakan tampilan untuk operasi kalender yang lebih dari sekadar operasi bilangan bulat.	Tidak digunakan di BigQuery.
`SET SESSION DATEFORM=ANSIDATE`	Tetapkan format tanggal sesi atau sistem ke ANSI (ISO 8601).	BigQuery selalu menggunakan ISO 8601, jadi pastikan Anda mengonversi tanggal dan waktu Teradata.

Sintaksis kueri

Bagian ini membahas perbedaan sintaksis kueri antara Teradata dan BigQuery.

Pernyataan `SELECT`

Sebagian besar pernyataan SELECT Teradata kompatibel dengan BigQuery. Tabel berikut berisi daftar perbedaan kecil.

Teradata		BigQuery
`SEL`		Konversikan ke `SELECT`. BigQuery tidak menggunakan singkatan `SEL`.
`SELECT (subquery) AS flag, CASE WHEN flag = 1 THEN ...`		Dalam BigQuery, kolom tidak dapat mereferensikan output dari kolom lain yang ditentukan dalam daftar pilihan yang sama. Memilih memindahkan subkueri ke klausa `WITH`. `WITH flags AS ( subquery ), SELECT CASE WHEN flags.flag = 1 THEN ...`
`SELECT * FROM table WHERE A LIKE ANY ('string1', 'string2')`		BigQuery tidak menggunakan predikat logika `ANY`. Fungsi yang sama dapat dicapai menggunakan beberapa operator `OR`: `SELECT * FROM table WHERE col LIKE 'string1' OR col LIKE 'string2'` Dalam hal ini, perbandingan string juga berbeda. Lihat Operator perbandingan.
`SELECT TOP 10 * FROM table`		BigQuery menggunakan `LIMIT` di akhir kueri, bukan `TOP n`, dengan mengikuti kata kunci `SELECT`.

Operator perbandingan

Tabel berikut menampilkan operator perbandingan Teradata yang khusus untuk Teradata dan harus dikonversi ke operator yang sesuai dengan ANSI SQL:2011 yang digunakan di BigQuery.

Untuk informasi tentang operator di BigQuery, lihat bagian Operator dalam dokumentasi BigQuery.

Teradata	BigQuery	Catatan
`exp EQ exp2` `exp IN (exp2, exp3)`	`exp = exp2` `exp IN (exp2, exp3)` Untuk mempertahankan semantik non-ANSI untuk `NOT CASESPECIFIC`, Anda dapat menggunakan `RTRIM(UPPER(exp)) = RTRIM(UPPER(exp2))`	Saat membandingkan string untuk kesamaan, Teradata mungkin mengabaikan spasi kosong di akhir, sedangkan BigQuery menganggapnya sebagai bagian dari string. Misalnya, `'xyz'=' xyz'` adalah `TRUE` di Teradata, tetapi `FALSE` di BigQuery. Teradata juga menyediakan atribut kolom `NOT CASESPECIFIC` yang menginstruksikan Teradata untuk mengabaikan kapitalisasi saat membandingkan dua string. BigQuery selalu bersifat spesifik per kasus saat membandingkan string. Misalnya, `'xYz' = 'xyz'` adalah `TRUE` di Teradata, tetapi `FALSE` di BigQuery.
`exp LE exp2`	`exp <= exp2`
`exp LT exp2`	`exp < exp2`
`exp NE exp2`	`exp <> exp2 exp != exp2`
`exp GE exp2`	`exp >= exp2`
`exp GT exp2`	`exp > exp2`

Kondisi `JOIN`

BigQuery dan Teradata mendukung kondisi JOIN, ON, dan USING yang sama. Tabel berikut berisi daftar perbedaan kecil.

Teradata	BigQuery	Catatan
`FROM A LEFT OUTER JOIN B ON A.date > B.start_date AND A.date < B.end_date`	`FROM A LEFT OUTER JOIN (SELECT d FROM B JOIN UNNEST(GENERATE_DATE_ARRAY(B.start_date, B.end_date)) d) B ON A.date = B.date`	BigQuery mendukung klausa `JOIN` ketidaksetaraan untuk semua gabungan dalam atau jika setidaknya satu kondisi kesetaraan diberikan (=). Namun, bukan hanya satu kondisi ketidaksetaraan (= dan <) dalam `OUTER JOIN`. Konstruksi tersebut terkadang digunakan untuk mengkueri rentang tanggal atau bilangan bulat. BigQuery mencegah pengguna membuat cross join berukuran besar secara tidak sengaja.
`FROM A, B ON A.id = B.id`	`FROM A JOIN B ON A.id = B.id`	Penggunaan koma di antara tabel di Teradata sama dengan `INNER JOIN`, sedangkan di BigQuery sama dengan `CROSS JOIN` (produk Kartesius). Karena koma di BigQuery SQL lama diperlakukan sebagai `UNION`, sebaiknya buat operasi menjadi eksplisit untuk menghindari kebingungan.
`FROM A JOIN B ON (COALESCE(A.id , 0) = COALESCE(B.id, 0))`	`FROM A JOIN B ON (COALESCE(A.id , 0) = COALESCE(B.id, 0))`	Tidak ada perbedaan untuk fungsi skalar (konstan).
`FROM A JOIN B ON A.id = (SELECT MAX(B.id) FROM B)`	`FROM A JOIN (SELECT MAX(B.id) FROM B) B1 ON A.id = B1.id`	BigQuery mencegah pengguna menggunakan subkueri, subkueri yang berkorelasi, atau agregasi dalam predikat gabungan. Hal ini memungkinkan BigQuery memparalelkan kueri.

Konversi jenis dan casting

BigQuery memiliki jenis data yang lebih sedikit tetapi lebih luas daripada Teradata. Hal ini mengharuskan BigQuery untuk melakukan transmisi dengan lebih ketat.

Teradata	BigQuery	Catatan
`exp EQ exp2` `exp IN (exp2, exp3)`	`exp = exp2` `exp IN (exp2, exp3)` Untuk mempertahankan semantik non-ANSI untuk `NOT CASESPECIFIC`, Anda dapat menggunakan `RTRIM(UPPER(exp)) = RTRIM(UPPER(exp2))`	Saat membandingkan string untuk kesamaan, Teradata mungkin mengabaikan spasi kosong di akhir, sedangkan BigQuery menganggapnya sebagai bagian dari string. Misalnya, `'xyz'=' xyz'` adalah `TRUE` di Teradata, tetapi `FALSE` di BigQuery. Teradata juga menyediakan atribut kolom `NOT CASESPECIFIC` yang menginstruksikan Teradata untuk mengabaikan kapitalisasi saat membandingkan dua string. BigQuery selalu bersifat spesifik per kasus saat membandingkan string. Misalnya, `'xYz' = 'xyz'` adalah `TRUE` di Teradata, tetapi `FALSE` di BigQuery.
`CAST(long_varchar_column AS CHAR(6))`	`LPAD(long_varchar_column, 6)`	Transmisi kolom karakter di Teradata terkadang digunakan sebagai cara non-standar dan tidak optimal untuk membuat substring dengan padding.
`CAST(92617 AS TIME) 92617 (FORMAT '99:99:99')`	`PARSE_TIME("%k%M%S", CAST(92617 AS STRING))`	Teradata melakukan banyak konversi jenis yang lebih implisit dan pembulatan daripada BigQuery, yang umumnya lebih ketat dan menerapkan standar ANSI. (Contoh ini menampilkan 09:26:17)
`CAST(48.5 (FORMAT 'zz') AS FLOAT)`	`CAST(SUBSTR(CAST(48.5 AS STRING), 0, 2) AS FLOAT64)`	Jenis data floating point dan numerik dapat memerlukan aturan pembulatan khusus saat diterapkan dengan format seperti mata uang. (Contoh ini menampilkan 48)

Lihat juga Operator perbandingan dan format kolom. Perbandingan dan pemformatan kolom dapat berperilaku seperti transmisi jenis.

Klausa `QUALIFY`, `ROWS`

Dengan klausa QUALIFY di Teradata, Anda dapat memfilter hasil untuk fungsi jendela. Atau, frasa ROWS dapat digunakan untuk tugas yang sama. Cara kerjanya mirip dengan kondisi HAVING untuk klausa GROUP, yang membatasi output dari apa yang disebut fungsi jendela di BigQuery.

Teradata BigQuery

SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1; Klausa QUALIFY Teradata dengan fungsi jendela seperti ROW_NUMBER(), SUM(), COUNT(), dan dengan OVER PARTITION BY dinyatakan dalam BigQuery sebagai WHERE pada subkueri yang berisi nilai analitik.

Menggunakan ROW_NUMBER().

SELECT col1, col2 FROM ( SELECT col1, col2, ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) RN FROM table ) WHERE RN = 1;

Menggunakan ARRAY_AGG, yang mendukung partisi lebih besar:

SELECT result.* FROM ( SELECT ARRAY_AGG(table ORDER BY table.col2 DESC LIMIT 1)[OFFSET(0)] FROM table GROUP BY col1 ) AS result;

SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 ROWS BETWEEN 2 PRECEDING AND CURRENT ROW); SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 RANGE BETWEEN 2 PRECEDING AND CURRENT ROW);

Di BigQuery, RANGE dan ROWS dapat digunakan dalam klausa frame jendela. Namun, klausa jendela hanya dapat digunakan dengan fungsi jendela seperti AVG(), bukan dengan fungsi penomoran seperti ROW_NUMBER().

Teradata	BigQuery
`SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1;`	Klausa `QUALIFY` Teradata dengan fungsi jendela seperti `ROW_NUMBER()`, `SUM()`, `COUNT()`, dan dengan `OVER PARTITION BY` dinyatakan dalam BigQuery sebagai `WHERE` pada subkueri yang berisi nilai analitik. Menggunakan `ROW_NUMBER()`. `SELECT col1, col2 FROM ( SELECT col1, col2, ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) RN FROM table ) WHERE RN = 1;` Menggunakan `ARRAY_AGG`, yang mendukung partisi lebih besar: `SELECT result.* FROM ( SELECT ARRAY_AGG(table ORDER BY table.col2 DESC LIMIT 1)[OFFSET(0)] FROM table GROUP BY col1 ) AS result;`
`SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 ROWS BETWEEN 2 PRECEDING AND CURRENT ROW);`	`SELECT col1, col2 FROM table AVG(col1) OVER (PARTITION BY col1 ORDER BY col2 RANGE BETWEEN 2 PRECEDING AND CURRENT ROW);` Di BigQuery, `RANGE` dan `ROWS` dapat digunakan dalam klausa frame jendela. Namun, klausa jendela hanya dapat digunakan dengan fungsi jendela seperti `AVG()`, bukan dengan fungsi penomoran seperti `ROW_NUMBER()`.

Kata kunci `NORMALIZE`

Teradata menyediakan kata kunci NORMALIZE untuk klausa SELECT guna menggabungkan periode atau interval yang tumpang-tindih ke dalam satu periode atau interval yang mencakup semua nilai periode individual.

BigQuery tidak mendukung jenis PERIOD, sehingga setiap kolom jenis PERIOD di Teradata harus dimasukkan ke dalam BigQuery sebagai dua kolom DATE atau DATETIME terpisah yang sesuai dengan awal dan akhir dari periode.

Teradata BigQuery

SELECT NORMALIZE client_id, item_sid, BEGIN(period) AS min_date, END(period) AS max_date, FROM table; SELECT t.client_id, t.item_sid, t.min_date, MAX(t.dwh_valid_to) AS max_date FROM ( SELECT d1.client_id, d1.item_sid, d1.dwh_valid_to AS dwh_valid_to, MIN(d2.dwh_valid_from) AS min_date FROM table d1 LEFT JOIN table d2 ON d1.client_id = d2.client_id AND d1.item_sid = d2.item_sid AND d1.dwh_valid_to >= d2.dwh_valid_from AND d1.dwh_valid_from < = d2.dwh_valid_to GROUP BY d1.client_id, d1.item_sid, d1.dwh_valid_to ) t GROUP BY t.client_id, t.item_sid, t.min_date;

Teradata	BigQuery
`SELECT NORMALIZE client_id, item_sid, BEGIN(period) AS min_date, END(period) AS max_date, FROM table;`	SELECT t.client_id, t.item_sid, t.min_date, MAX(t.dwh_valid_to) AS max_date FROM ( SELECT d1.client_id, d1.item_sid, d1.dwh_valid_to AS dwh_valid_to, MIN(d2.dwh_valid_from) AS min_date FROM table d1 LEFT JOIN table d2 ON d1.client_id = d2.client_id AND d1.item_sid = d2.item_sid AND d1.dwh_valid_to >= d2.dwh_valid_from AND d1.dwh_valid_from < = d2.dwh_valid_to GROUP BY d1.client_id, d1.item_sid, d1.dwh_valid_to ) t GROUP BY t.client_id, t.item_sid, t.min_date;

Functions

Bagian berikut mencantumkan pemetaan antara fungsi Teradata dan BigQuery yang setara.

Fungsi agregat

Tabel berikut memetakan agregat Teradata, agregat statistik, dan perkiraan fungsi agregat ke BigQuery yang setara dengan BigQuery. BigQuery menawarkan fungsi agregat tambahan berikut:

Teradata	BigQuery
`AVG`	`AVG`
`BITAND`	`BIT_AND`
`BITNOT`	Operator bukan bitwise (`~`)
`BITOR`	`BIT_OR`
`BITXOR`	`BIT_XOR`
`CORR`	`CORR`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`MAX`	`MAX`
`MIN`	`MIN`
`REGR_AVGX`	`AVG( IF(dep_var_expression is NULL OR ind_var_expression is NULL, NULL, ind_var_expression) )`
`REGR_AVGY`	`AVG( IF(dep_var_expression is NULL OR ind_var_expression is NULL, NULL, dep_var_expression) )`
`REGR_COUNT`	`SUM( IF(dep_var_expression is NULL OR ind_var_expression is NULL, NULL, 1) )`
`REGR_INTERCEPT`	`AVG(dep_var_expression) - AVG(ind_var_expression) * (COVAR_SAMP(ind_var_expression, dep_var_expression) / VARIANCE(ind_var_expression))`
`REGR_R2`	`(COUNT(dep_var_expression)* SUM(ind_var_expression * dep_var_expression) - SUM(dep_var_expression) * SUM(ind_var_expression)) / SQRT( (COUNT(ind_var_expression)* SUM(POWER(ind_var_expression, 2))* POWER(SUM(ind_var_expression),2))* (COUNT(dep_var_expression)* SUM(POWER(dep_var_expression, 2))* POWER(SUM(dep_var_expression), 2)))`
`REGR_SLOPE`	`- COVAR_SAMP(ind_var_expression, dep_var_expression) / VARIANCE(ind_var_expression)`
`REGR_SXX`	`SUM(POWER(ind_var_expression, 2)) - COUNT(ind_var_expression) * POWER(AVG(ind_var_expression),2)`
`REGR_SXY`	`SUM(ind_var_expression * dep_var_expression) - COUNT(ind_var_expression) * AVG(ind_var_expression) * AVG(dep_var_expression)`
`REGR_SYY`	`SUM(POWER(dep_var_expression, 2)) - COUNT(dep_var_expression) * POWER(AVG(dep_var_expression),2)`
`SKEW`	Fungsi kustom yang ditentukan pengguna.
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`

Fungsi analisis dan fungsi jendela

Tabel berikut memetakan fungsi analisis Teradata umum dan menggabungkan fungsi analisis ke fungsi jendela BigQuery yang setara. BigQuery menawarkan fungsi tambahan berikut:

Teradata	BigQuery
`ARRAY_AGG`	`ARRAY_AGG`
`ARRAY_CONCAT, (\|\| operator)`	`ARRAY_CONCAT_AGG, (\|\| operator)`
`BITAND`	`BIT_AND`
`BITNOT`	Operator bukan bitwise (`~`)
`BITOR`	`BIT_OR`
`BITXOR`	`BIT_XOR`
`CORR`	`CORR`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`CUME_DIST`	`CUME_DIST`
`DENSE_RANK` (ANSI)	`DENSE_RANK`
`FIRST_VALUE`	`FIRST_VALUE`
`LAST_VALUE`	`LAST_VALUE`
`MAX`	`MAX`
`MIN`	`MIN`
`PERCENT_RANK`	`PERCENT_RANK`
`PERCENTILE_CONT`, `PERCENTILE_DISC`	`PERCENTILE_CONT`, `PERCENTILE_DISC`
`RANK` (ANSI)	`RANK`
`ROW_NUMBER`	`ROW_NUMBER`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`

Fungsi tanggal/waktu

Tabel berikut memetakan fungsi tanggal/waktu umum Teradata ke BigQuery yang setara. BigQuery menawarkan fungsi tanggal/waktu tambahan berikut:

Teradata	BigQuery
`ADD_MONTHS`	`DATE_ADD, TIMESTAMP_ADD`
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_TIME`	`CURRENT_TIME`
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`
`DATE + k`	`DATE_ADD(date_expression, INTERVAL k DAY)`
`DATE - k`	`DATE_SUB(date_expression, INTERVAL k DAY)`
`EXTRACT`	`EXTRACT(DATE), EXTRACT(TIMESTAMP)`
	`FORMAT_DATE`
	`FORMAT_DATETIME`
	`FORMAT_TIME`
	`FORMAT_TIMESTAMP`
`LAST_DAY`	`LAST_DAY` Catatan: Fungsi ini mendukung ekspresi input `DATE` dan `DATETIME`.
`MONTHS_BETWEEN`	`DATE_DIFF(date_expression, date_expression, MONTH)`
`NEXT_DAY`	`DATE_ADD( DATE_TRUNC( date_expression, WEEK(day_value) ), INTERVAL 1 WEEK )`
`OADD_MONTHS`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL num_months MONTH ), MONTH ), INTERVAL 1 DAY )`
`td_day_of_month`	`EXTRACT(DAY FROM date_expression) EXTRACT(DAY FROM timestamp_expression)`
`td_day_of_week`	`EXTRACT(DAYOFWEEK FROM date_expression) EXTRACT(DAYOFWEEK FROM timestamp_expression)`
`td_day_of_year`	`EXTRACT(DAYOFYEAR FROM date_expression) EXTRACT(DAYOFYEAR FROM timestamp_expression)`
`td_friday`	`DATE_TRUNC( date_expression, WEEK(FRIDAY) )`
`td_monday`	`DATE_TRUNC( date_expression, WEEK(MONDAY) )`
`td_month_begin`	`DATE_TRUNC(date_expression, MONTH)`
`td_month_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 MONTH ), MONTH ), INTERVAL 1 DAY )`
`td_month_of_calendar`	`(EXTRACT(YEAR FROM date_expression) - 1900) * 12 + EXTRACT(MONTH FROM date_expression)`
`td_month_of_quarter`	`EXTRACT(MONTH FROM date_expression) - ((EXTRACT(QUARTER FROM date_expression) - 1) * 3)`
`td_month_of_year`	`EXTRACT(MONTH FROM date_expression) EXTRACT(MONTH FROM timestamp_expression)`
`td_quarter_begin`	`DATE_TRUNC(date_expression, QUARTER)`
`td_quarter_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 QUARTER ), QUARTER ), INTERVAL 1 DAY )`
`td_quarter_of_calendar`	`(EXTRACT(YEAR FROM date_expression) - 1900) * 4 + EXTRACT(QUARTER FROM date_expression)`
`td_quarter_of_year`	`EXTRACT(QUARTER FROM date_expression) EXTRACT(QUARTER FROM timestamp_expression)`
`td_saturday`	`DATE_TRUNC( date_expression, WEEK(SATURDAY) )`
`td_sunday`	`DATE_TRUNC( date_expression, WEEK(SUNDAY) )`
`td_thursday`	`DATE_TRUNC( date_expression, WEEK(THURSDAY) )`
`td_tuesday`	`DATE_TRUNC( date_expression, WEEK(TUESDAY) )`
`td_wednesday`	`DATE_TRUNC( date_expression, WEEK(WEDNESDAY) )`
`td_week_begin`	`DATE_TRUNC(date_expression, WEEK)`
`td_week_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 WEEK ), WEEK ), INTERVAL 1 DAY )`
`td_week_of_calendar`	`(EXTRACT(YEAR FROM date_expression) - 1900) * 52 + EXTRACT(WEEK FROM date_expression)`
`td_week_of_month`	`EXTRACT(WEEK FROM date_expression) - EXTRACT(WEEK FROM DATE_TRUNC(date_expression, MONTH))`
`td_week_of_year`	`EXTRACT(WEEK FROM date_expression) EXTRACT(WEEK FROM timestamp_expression)`
`td_weekday_of_month`	`CAST( CEIL( EXTRACT(DAY FROM date_expression) / 7 ) AS INT64 )`
`td_year_begin`	`DATE_TRUNC(date_expression, YEAR)`
`td_year_end`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 YEAR ), YEAR ), INTERVAL 1 DAY )`
`td_year_of_calendar`	`EXTRACT(YEAR FROM date_expression)`
`TO_DATE`	`PARSE_DATE`
`TO_TIMESTAMP`	`PARSE_TIMESTAMP`
`TO_TIMESTAMP_TZ`	`PARSE_TIMESTAMP`

Fungsi string

Tabel berikut memetakan fungsi string Teradata ke BigQuery yang setara. BigQuery menawarkan fungsi string tambahan berikut:

Teradata	BigQuery
`ASCII`	`TO_CODE_POINTS(string_expression)[OFFSET(0)]`
`CHAR2HEXINT`	`TO_HEX`
`CHARACTER LENGTH`	`CHAR_LENGTH`
`CHARACTER LENGTH`	`CHARACTER_LENGTH`
`CHR`	`CODE_POINTS_TO_STRING( [mod(numeric_expression, 256)] )`
`CONCAT, (\|\| operator)`	`CONCAT, (\|\| operator)`
`CSV`	Fungsi kustom yang ditentukan pengguna.
`CSVLD`	Fungsi kustom yang ditentukan pengguna.
`FORMAT`	`FORMAT`
`INDEX`	`STRPOS(string, substring)`
`INITCAP`	`INITCAP`
`INSTR`	Fungsi kustom yang ditentukan pengguna.
`LEFT`	`SUBSTR(source_string, 1, length)`
`LENGTH`	`LENGTH`
`LOWER`	`LOWER`
`LPAD`	`LPAD`
`LTRIM`	`LTRIM`
`NGRAM`	Fungsi kustom yang ditentukan pengguna.
`NVP`	Fungsi kustom yang ditentukan pengguna.
`OREPLACE`	`REPLACE`
`OTRANSLATE`	Fungsi kustom yang ditentukan pengguna.
`POSITION`	`STRPOS(string, substring)`
`REGEXP_INSTR`	`STRPOS(source_string, REGEXP_EXTRACT(source_string, regexp_string))` Catatan: Menampilkan kemunculan pertama.
`REGEXP_REPLACE`	`REGEXP_REPLACE`
`REGEXP_SIMILAR`	`IF(REGEXP_CONTAINS,1,0)`
`REGEXP_SUBSTR`	`REGEXP_EXTRACT, REGEXP_EXTRACT_ALL`
`REGEXP_SPLIT_TO_TABLE`	Fungsi kustom yang ditentukan pengguna.
`REVERSE`	`REVERSE`
`RIGHT`	`SUBSTR(source_string, -1, length)`
`RPAD`	`RPAD`
`RTRIM`	`RTRIM`
`STRTOK` Catatan: Setiap karakter dalam argumen string pembatas dianggap sebagai karakter pembatas yang terpisah. Pemisah defaultnya adalah karakter spasi.	`SPLIT(instring, delimiter)[ORDINAL(tokennum)]` Catatan: Seluruh argumen string pembatas digunakan sebagai pembatas tunggal. Pemisah defaultnya adalah koma.
`STRTOK_SPLIT_TO_TABLE`	Fungsi kustom yang ditentukan pengguna
`SUBSTRING`, `SUBSTR`	`SUBSTR`
`TRIM`	`TRIM`
`UPPER`	`UPPER`

Fungsi matematika

Tabel berikut memetakan fungsi matematika Teradata ke BigQuery yang setara. BigQuery menawarkan fungsi matematika tambahan berikut:

Teradata	BigQuery
`ABS`	`ABS`
`ACOS`	`ACOS`
`ACOSH`	`ACOSH`
`ASIN`	`ASIN`
`ASINH`	`ASINH`
`ATAN`	`ATAN`
`ATAN2`	`ATAN2`
`ATANH`	`ATANH`
`CEILING`	`CEIL`
`CEILING`	`CEILING`
`COS`	`COS`
`COSH`	`COSH`
`EXP`	`EXP`
`FLOOR`	`FLOOR`
`GREATEST`	`GREATEST`
`LEAST`	`LEAST`
`LN`	`LN`
`LOG`	`LOG`
`MOD` (operator `%`)	`MOD`
`NULLIFZERO`	`NULLIF(expression, 0)`
`POWER` (operator `**`)	`POWER, POW`
`RANDOM`	`RAND`
`ROUND`	`ROUND`
`SIGN`	`SIGN`
`SIN`	`SIN`
`SINH`	`SINH`
`SQRT`	`SQRT`
`TAN`	`TAN`
`TANH`	`TANH`
`TRUNC`	`TRUNC`
`ZEROIFNULL`	`IFNULL(expression, 0), COALESCE(expression, 0)`

Sintaksis DML

Bagian ini membahas perbedaan sintaksis bahasa pengelolaan data antara Teradata dan BigQuery.

Pernyataan `INSERT`

Sebagian besar pernyataan INSERT Teradata kompatibel dengan BigQuery. Tabel berikut menunjukkan pengecualian.

Skrip DML di BigQuery memiliki semantik konsistensi yang sedikit berbeda dengan pernyataan yang setara di Teradata. Untuk ringkasan snapshot isolation serta penanganan sesi dan transaksi, lihat bagian CREATE INDEX di tempat lain dalam dokumen ini.

Teradata BigQuery

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

Teradata menawarkan kata kunci DEFAULT untuk kolom non-nullable.

Catatan: Di BigQuery, menghilangkan nama kolom dalam pernyataan INSERT hanya berfungsi jika nilai untuk semua kolom dalam tabel target dimasukkan dalam urutan naik berdasarkan posisi ordinal mereka.

Teradata	BigQuery
`INSERT INTO table VALUES (...);`	`INSERT INTO table (...) VALUES (...);` Teradata menawarkan kata kunci `DEFAULT` untuk kolom non-nullable. Catatan: Di BigQuery, menghilangkan nama kolom dalam pernyataan `INSERT` hanya berfungsi jika nilai untuk semua kolom dalam tabel target dimasukkan dalam urutan naik berdasarkan posisi ordinal mereka.
`INSERT INTO table VALUES (1,2,3); INSERT INTO table VALUES (4,5,6); INSERT INTO table VALUES (7,8,9);`	`INSERT INTO table VALUES (1,2,3), (4,5,6), (7,8,9);` Teradata memiliki konsep permintaan multi-pernyataan (MSR), yang mengirim beberapa pernyataan `INSERT` dalam satu waktu. Di BigQuery, opsi ini tidak direkomendasikan karena adanya batas transaksi implisit antar pernyataan. Sebagai gantinya, gunakan `INSERT` multi-nilai. BigQuery mengizinkan pernyataan `INSERT` serentak, tetapi dapat mengantrekan `UPDATE`. Untuk meningkatkan performa, pertimbangkan pendekatan berikut: Menggabungkan beberapa baris dalam satu pernyataan `INSERT`, bukan satu baris per operasi `INSERT`. Menggabungkan beberapa pernyataan DML (termasuk `INSERT`) menggunakan pernyataan `MERGE`. Menggunakan `CREATE TABLE ... AS SELECT` untuk membuat dan mengisi tabel baru, bukan `UPDATE` atau `DELETE`, khususnya saat membuat kueri kolom yang dipartisi atau rollback atau memulihkan.


INSERT INTO table VALUES (1,2,3);

INSERT INTO table VALUES (4,5,6);

INSERT INTO table VALUES (7,8,9);


INSERT INTO
table VALUES (1,2,3),

                         (4,5,6),

                         (7,8,9);

Teradata memiliki konsep permintaan multi-pernyataan (MSR), yang mengirim beberapa pernyataan INSERT dalam satu waktu. Di BigQuery, opsi ini tidak direkomendasikan karena adanya batas transaksi implisit antar pernyataan. Sebagai gantinya, gunakan INSERT multi-nilai.

BigQuery mengizinkan pernyataan INSERT serentak, tetapi dapat mengantrekan UPDATE. Untuk meningkatkan performa, pertimbangkan pendekatan berikut:

Menggabungkan beberapa baris dalam satu pernyataan INSERT, bukan satu baris per operasi INSERT.
Menggabungkan beberapa pernyataan DML (termasuk INSERT) menggunakan pernyataan MERGE.
Menggunakan CREATE TABLE ... AS SELECT untuk membuat dan mengisi tabel baru, bukan UPDATE atau DELETE, khususnya saat membuat kueri kolom yang dipartisi atau rollback atau memulihkan.

Pernyataan `UPDATE`

Sebagian besar pernyataan UPDATE Teradata kompatibel dengan BigQuery, kecuali untuk item berikut:

Saat Anda menggunakan klausa FROM, pengurutan klausa FROM dan SET dibalik di Teradata dan BigQuery.
Di GoogleSQL, setiap pernyataan UPDATE harus menyertakan kata kunci WHERE, diikuti dengan kondisi. Untuk memperbarui semua baris dalam tabel, gunakan WHERE true.

Sebagai praktik terbaik, Anda harus mengelompokkan beberapa mutasi DML, bukan pernyataan UPDATE dan INSERT tunggal. Skrip DML di BigQuery memiliki semantik konsistensi yang sedikit berbeda dengan pernyataan yang setara di Teradata. Untuk ringkasan tentang snapshot isolation serta penanganan sesi dan transaksi, lihat bagian CREATE INDEX di tempat lain dalam dokumen ini.

Tabel berikut menampilkan pernyataan UPDATE Teradata dan pernyataan BigQuery yang menyelesaikan tugas yang sama.

Untuk mengetahui informasi selengkapnya tentang UPDATE di BigQuery, lihat contoh UPDATE BigQuery dalam dokumentasi DML.

Teradata		BigQuery
`UPDATE table_A FROM table_A, table_B SET y = table_B.y, z = table_B.z + 1 WHERE table_A.x = table_B.x AND table_A.y IS NULL;`		`UPDATE table_A SET y = table_B.y, z = table_B.z + 1 FROM table_B WHERE table_A.x = table_B.x AND table_A.y IS NULL;`
`UPDATE table alias SET x = x + 1 WHERE f(x) IN (0, 1);`		`UPDATE table SET x = x + 1 WHERE f(x) IN (0, 1);`
`UPDATE table_A FROM table_A, table_B, B SET z = table_B.z WHERE table_A.x = table_B.x AND table_A.y = table_B.y;`		`UPDATE table_A SET z = table_B.z FROM table_B WHERE table_A.x = table_B.x AND table_A.y = table_B.y;`

Pernyataan `DELETE` dan `TRUNCATE`

Pernyataan DELETE dan TRUNCATE adalah cara untuk menghapus baris dari tabel tanpa memengaruhi skema atau indeks tabel. TRUNCATE tidak digunakan baik di Teradata maupun BigQuery. Namun, Anda dapat menggunakan pernyataan DELETE untuk mencapai efek yang sama.

Di BigQuery, pernyataan DELETE harus memiliki klausa WHERE. Untuk menghapus semua baris dalam tabel (potong), gunakan WHERE true. Guna mempercepat operasi pemotongan untuk tabel yang sangat besar, sebaiknya gunakan pernyataan CREATE OR REPLACE TABLE ... AS SELECT, dengan menggunakan LIMIT 0 pada tabel yang sama untuk menggantikannya sendiri. Namun, pastikan untuk menambahkan informasi partisi dan pengelompokan secara manual saat menggunakannya.

Teradata kemudian melakukan vakum untuk menghapus baris. Ini berarti bahwa operasi DELETE awalnya lebih cepat daripada di BigQuery, tetapi nantinya akan memerlukan resource, terutama operasi DELETE berskala besar yang memengaruhi sebagian besar tabel. Untuk menggunakan pendekatan serupa di BigQuery, sebaiknya kurangi jumlah operasi DELETE, misalnya dengan menyalin baris yang tidak akan dihapus ke tabel baru. Atau, Anda dapat menghapus seluruh partisi. Kedua opsi ini dirancang agar menjadi operasi yang lebih cepat daripada mutasi DML atomik.

Untuk mengetahui informasi selengkapnya tentang DELETE di BigQuery, lihat contoh DELETE dalam dokumentasi DML.

Teradata	BigQuery
`BEGIN TRANSACTION; LOCKING TABLE table_A FOR EXCLUSIVE; DELETE FROM table_A; INSERT INTO table_A SELECT * FROM table_B; END TRANSACTION;`	Mengganti konten tabel dengan output kueri setara dengan transaksi. Anda dapat melakukannya dengan operasi kueri atau operasi salinan. Menggunakan operasi kueri: `bq query --replace --destination_table table_A 'SELECT * FROM table_B';` Menggunakan operasi salinan: `bq cp -f table_A table_B`
`DELETE database.table ALL;`	`DELETE FROM table WHERE TRUE;` Atau untuk tabel yang sangat besar dengan cara yang lebih cepat: `CREATE OR REPLACE table AS SELECT * FROM table LIMIT 0;`

Pernyataan `MERGE`

Pernyataan MERGE dapat menggabungkan operasi INSERT, UPDATE, dan DELETE menjadi satu pernyataan "upsert" dan melakukan operasi secara atomik. Operasi MERGE harus cocok dengan maksimal satu baris sumber untuk setiap baris target. BigQuery dan Teradata mengikuti Sintaksis ANSI.

Operasi MERGE Teradata dibatasi untuk kunci utama yang cocok dalam satu pemroses modul akses (AMP). Sebaliknya, BigQuery tidak memiliki batasan ukuran atau kolom untuk operasi MERGE, sehingga penggunaan MERGE adalah pengoptimalan yang bermanfaat. Namun, jika MERGE utamanya adalah penghapusan besar, lihat pengoptimalan untuk DELETE di bagian lain dalam dokumen ini.

Skrip DML di BigQuery memiliki semantik konsistensi yang sedikit berbeda dengan pernyataan yang setara di Teradata. Misalnya, tabel SET Teradata dalam mode sesi dapat mengabaikan duplikat selama operasi MERGE. Untuk ringkasan tentang penanganan tabel MULTISET dan SET, snapshot isolation, serta penanganan sesi dan transaksi, lihat bagian CREATE INDEX di tempat lain dalam dokumen ini.

Variabel yang terpengaruh baris

Di Teradata, variabel ACTIVITY_COUNT adalah ekstensi SQL Teradata ANSI yang diisi dengan jumlah baris yang terpengaruh oleh pernyataan DML.

Variabel sistem @@row_count di Fitur pembuatan skrip memiliki fungsi yang serupa. Di BigQuery, akan lebih umum untuk memeriksa nilai yang ditampilkan numDmlAffectedRows di log audit atau tampilan INFORMATION_SCHEMA.

Sintaksis DDL

Bagian ini membahas perbedaan sintaksis bahasa definisi data antara Teradata dan BigQuery.

Pernyataan `CREATE TABLE`

Sebagian besar pernyataan CREATE TABLE Teradata kompatibel dengan BigQuery, kecuali untuk elemen sintaksis berikut, yang tidak digunakan di BigQuery:

MULTISET. Lihat bagian CREATE INDEX.
VOLATILE. Lihat bagian Tabel sementara.
[NO] FALLBACK. Lihat bagian Rollback.
[NO] BEFORE JOURNAL, [NO] AFTER JOURNAL
CHECKSUM = DEFAULT | val
DEFAULT MERGEBLOCKRATIO
PRIMARY INDEX (col, ...). Lihat bagian CREATE INDEX.
UNIQUE PRIMARY INDEX. Lihat bagian CREATE INDEX.
CONSTRAINT
DEFAULT
IDENTITY

Untuk mengetahui informasi selengkapnya tentang CREATE TABLE di BigQuery, lihat contoh CREATE BigQuery dalam dokumentasi DML.

Opsi dan atribut kolom

Spesifikasi kolom berikut untuk pernyataan CREATE TABLE tidak digunakan di BigQuery:

FORMAT 'format'. Lihat bagian pemformatan jenis Teradata.
CHARACTER SET name. BigQuery selalu menggunakan encoding UTF-8.
[NOT] CASESPECIFIC
COMPRESS val | (val, ...)

Teradata memperluas standar ANSI dengan opsi kolom TITLE. Fitur ini dapat diterapkan juga di BigQuery menggunakan deskripsi kolom seperti yang ditunjukkan pada tabel berikut. Perlu diperhatikan bahwa opsi ini tidak tersedia untuk View.

Teradata	BigQuery
`CREATE TABLE table ( col1 VARCHAR(30) TITLE 'column desc' );`	`CREATE TABLE dataset.table ( col1 STRING OPTIONS(description="column desc") );`

Tabel sementara

Teradata mendukung tabel volatil, yang sering digunakan untuk menyimpan hasil perantara dalam skrip. Ada beberapa cara untuk mencapai sesuatu yang mirip dengan tabel volatil di BigQuery:

CREATE TEMPORARY TABLE dapat digunakan dalam Pembuatan skrip, dan valid selama masa pakai skrip. Jika tabel harus ada di luar skrip, Anda dapat menggunakan opsi lain dalam daftar ini.
TTL set data: Membuat set data yang memiliki time to live (TTL) singkat (misalnya, 1 jam) sehingga tabel yang dibuat dalam set data bersifat sementara karena tidak akan dipertahankan lebih lama dari time to live (TTL) set data. Anda dapat memberikan awalan untuk semua nama tabel dalam set data ini dengan temp untuk menunjukkan dengan jelas bahwa tabel tersebut bersifat sementara.
Tabel TTL: Membuat tabel yang memiliki time to live (TTL) singkat khusus tabel menggunakan pernyataan DDL yang mirip dengan berikut ini:
```
CREATE TABLE temp.name (col1, col2, ...)
OPTIONS(expiration_timestamp=TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL 1 HOUR));
```
Klausa WITH: Jika tabel sementara hanya diperlukan dalam blok yang sama, gunakan hasil sementara menggunakan pernyataan WITH atau subkueri. Ini adalah opsi yang paling efisien.

Pola yang sering digunakan dalam skrip Teradata (BTEQ) adalah membuat tabel permanen, menyisipkan nilai di dalamnya, menggunakannya seperti tabel sementara dalam pernyataan yang sedang berlangsung, lalu menghapusnya atau memotong tabel setelahnya. Akibatnya, tabel tersebut digunakan sebagai variabel konstan (semaphore). Pendekatan ini tidak efisien di BigQuery, dan sebaiknya gunakan variabel nyata di Pembuatan skrip, atau gunakan CREATE OR REPLACE dengan sintaksis kueri AS SELECT untuk membuat tabel yang sudah memiliki nilai di dalamnya.

Pernyataan `CREATE VIEW`

Tabel berikut menunjukkan padanan antara Teradata dan BigQuery untuk pernyataan CREATE VIEW. Klausa untuk penguncian tabel seperti LOCKING ROW FOR ACCESS tidak diperlukan dalam BigQuery.

Teradata	BigQuery	Catatan
`CREATE VIEW view_name AS SELECT ...`	`CREATE VIEW view_name AS SELECT ...`
`REPLACE VIEW view_name AS SELECT ...`	`CREATE OR REPLACE VIEW view_name AS SELECT ...`
Tidak didukung	`CREATE VIEW IF NOT EXISTS OPTIONS(view_option_list) AS SELECT ...`	Membuat tampilan baru hanya jika tampilan saat ini tidak ada dalam set data yang ditentukan.

Pernyataan `CREATE [UNIQUE] INDEX`

Teradata memerlukan indeks untuk semua tabel dan memerlukan solusi khusus seperti tabel MULTISET dan Tabel NoPI agar dapat digunakan dengan data yang tidak unik atau tidak diindeks.

BigQuery tidak memerlukan indeks. Bagian ini menjelaskan pendekatan di BigQuery terkait cara membuat fungsionalitas yang mirip dengan penggunaan indeks di Teradata ketika terdapat kebutuhan logika bisnis yang sebenarnya.

Pengindeksan untuk performa

Karena merupakan database berorientasi kolom dengan pengoptimalan kueri dan penyimpanan, BigQuery tidak memerlukan indeks eksplisit. BigQuery menyediakan fungsionalitas seperti partisi dan pengelompokan serta kolom bertingkat, yang dapat meningkatkan efisiensi dan performa kueri dengan mengoptimalkan cara penyimpanan data.

Teradata tidak mendukung tampilan terwujud. Namun, metode ini menawarkan indeks join menggunakan pernyataan CREATE JOIN INDEX yang pada dasarnya mewujudkan data yang diperlukan untuk join. BigQuery tidak memerlukan indeks terwujud untuk mempercepat performa, seperti halnya BigQuery tidak memerlukan ruang spool khusus untuk join.

Untuk kasus pengoptimalan lainnya, tampilan terwujud dapat digunakan.

Pengindeksan untuk konsistensi (UNIQUE, PRIMARY INDEX)

Di Teradata, indeks unik dapat digunakan untuk mencegah baris dengan kunci non-unik dalam tabel. Jika sebuah proses mencoba menyisipkan atau memperbarui data yang memiliki nilai yang sudah ada dalam indeks, operasi akan gagal dengan pelanggaran indeks (tabel MULTISET) atau mengabaikannya secara diam-diam (tabel SET).

Karena BigQuery tidak menyediakan indeks eksplisit, pernyataan MERGE dapat digunakan untuk menyisipkan hanya data unik ke dalam tabel target dari tabel staging sambil menghapus data duplikat. Namun, tidak ada cara untuk mencegah pengguna yang memiliki izin edit agar tidak menyisipkan data duplikat, karena BigQuery tidak pernah mengunci selama operasi INSERT. Untuk menghasilkan error pada data duplikat di BigQuery, Anda dapat menggunakan pernyataan MERGE dari tabel staging, seperti yang ditunjukkan pada contoh berikut.

Teradata		BigQuery
`CREATE [UNIQUE] INDEX name;`		MERGE `prototype.FIN_MERGE` t USING `prototype.FIN_TEMP_IMPORT` m ON t.col1 = m.col1 AND t.col2 = m.col2 WHEN MATCHED THEN UPDATE SET t.col1 = ERROR(CONCAT('Encountered error for ', m.col1, ' ', m.col2)) WHEN NOT MATCHED THEN INSERT (col1,col2,col3,col4,col5,col6,col7,col8) VALUES(col1,col2,col3,col4,col5,col6,CURRENT_TIMESTAMP(),CURRENT_TIMESTAMP());

Lebih sering, pengguna lebih memilih untuk menghapus duplikat secara terpisah untuk menemukan error dalam sistem downstream.
BigQuery tidak mendukung kolom DEFAULT dan IDENTITY (urutan).

Pengindeksan untuk mencapai penguncian

Teradata menyediakan resource di pemroses modul akses (AMP); kueri dapat menggunakan resource semua AMP, AMP tunggal, atau grup AMP. Pernyataan DDL berupa semua AMP dan karenanya mirip dengan kunci DDL global. BigQuery tidak memiliki mekanisme kunci seperti ini dan dapat menjalankan kueri serentak dan pernyataan INSERT sesuai kuota Anda; hanya pernyataan DML UPDATE serentak yang memiliki implikasi serentak tertentu: Operasi UPDATE terhadap partisi yang sama dimasukkan ke dalam antrean untuk memastikan snapshot isolation, sehingga Anda tidak perlu mengunci untuk mencegah pembacaan semu atau hilangnya update.

Karena perbedaan ini, elemen Teradata berikut tidak digunakan di BigQuery:

ON COMMIT DELETE ROWS;
ON COMMIT PRESERVE ROWS;

Pernyataan SQL prosedural

Bagian ini menjelaskan cara mengonversi pernyataan SQL prosedural yang digunakan dalam prosedur, fungsi, dan pemicu tersimpan dari Teradata ke Pembuatan skrip, prosedur, atau fungsi yang ditentukan pengguna (UDF) BigQuery. Semua ini tersedia bagi administrator sistem untuk diperiksa menggunakan tampilan INFORMATION_SCHEMA.

Pernyataan `CREATE PROCEDURE`

Prosedur tersimpan didukung sebagai bagian dari Pembuatan skrip BigQuery.

Di BigQuery, Pembuatan skrip mengacu pada semua penggunaan pernyataan kontrol, sedangkan prosedur diberi nama skrip (dengan argumen jika diperlukan) yang dapat dipanggil dari Skrip lain dan disimpan secara permanen, jika diperlukan. Fungsi yang ditentukan pengguna (UDF) juga dapat ditulis dalam JavaScript.

Teradata	BigQuery
`CREATE PROCEDURE`	`CREATE PROCEDURE` jika nama diperlukan. Jika tidak, gunakan inline dengan `BEGIN` atau dalam satu baris dengan `CREATE TEMP FUNCTION`.
`REPLACE PROCEDURE`	`CREATE OR REPLACE PROCEDURE`
`CALL`	`CALL`

Bagian berikut ini menjelaskan cara mengonversi pernyataan prosedural Teradata yang ada menjadi pernyataan Pembuatan skrip BigQuery yang memiliki fungsi serupa.

Deklarasi dan penetapan variabel

Variabel BigQuery valid selama masa pakai skrip.

Teradata	BigQuery
`DECLARE`	`DECLARE`
`SET`	`SET`

Pengendali kondisi error

Teradata menggunakan pengendali pada kode status dalam prosedur kontrol error. Di BigQuery, penanganan error adalah fitur inti dari alur kontrol utama, mirip dengan yang disediakan oleh bahasa lain dengan blok TRY ... CATCH.

Teradata	BigQuery
`DECLARE EXIT HANDLER FOR SQLEXCEPTION`	`BEGIN ... EXCEPTION WHEN ERROR THEN`
`SIGNAL sqlstate`	`RAISE message`
`DECLARE CONTINUE HANDLER FOR SQLSTATE VALUE 23505;`	Pengendali pengecualian yang dipicu untuk kondisi error tertentu tidak digunakan oleh BigQuery. Sebaiknya gunakan pernyataan `ASSERT` saat kondisi keluar digunakan untuk prapemeriksaan atau proses debug, karena pernyataan ini sesuai dengan ANSI SQL:2011.

Variabel SQLSTATE di Teradata mirip dengan variabel sistem @@error di BigQuery. Di BigQuery, penyelidikan error lebih umum dilakukan menggunakan log audit atau tampilan INFORMATION_SCHEMA.

Deklarasi dan operasi kursor

Karena BigQuery tidak mendukung kursor atau sesi, pernyataan berikut tidak digunakan di BigQuery:

DECLARE cursor_name CURSOR [FOR | WITH] ...
PREPARE stmt_id FROM sql_str;
OPEN cursor_name [USING var, ...];
FETCH cursor_name INTO var, ...;
CLOSE cursor_name;

Pernyataan SQL dinamis

Fitur pembuatan skrip di BigQuery mendukung pernyataan SQL dinamis seperti yang ditunjukkan dalam tabel berikut.

Teradata	BigQuery
`EXECUTE IMMEDIATE sql_str;`	`EXECUTE IMMEDIATE sql_str;`
`EXECUTE stmt_id [USING var,...];`	`EXECUTE IMMEDIATE stmt_id USING var;`

Pernyataan Dynamic SQL berikut tidak digunakan di BigQuery:

PREPARE stmt_id FROM sql_str;

Pernyataan flow-of-control

Fitur pembuatan skrip di BigQuery mendukung pernyataan flow-of-control seperti yang ditunjukkan dalam tabel berikut.

Teradata	BigQuery
`IF condition THEN stmts ELSE stmts END IF`	`IF condition THEN stmts ELSE stmts END IF`
`label_name: LOOP stmts END LOOP label_name;`	Konstruksi blok bergaya GOTO tidak digunakan di BigQuery. Sebaiknya tulis ulang fungsi tersebut sebagai fungsi yang ditentukan pengguna (UDF) atau gunakan pernyataan `ASSERT` yang digunakan untuk penanganan error.
`REPEAT stmts UNTIL condition END REPEAT;`	`WHILE condition DO stmts END WHILE`
`LEAVE outer_proc_label;`	`LEAVE` tidak digunakan untuk blok bergaya GOTO; `LEAVE` digunakan sebagai sinonim untuk `BREAK` guna keluar dari loop `WHILE`.
`LEAVE label;`	`LEAVE` tidak digunakan untuk blok bergaya GOTO; `LEAVE` digunakan sebagai sinonim untuk `BREAK` guna keluar dari loop `WHILE`.
`WITH RECURSIVE temp_table AS ( ... );`	Kueri rekursif (juga dikenal sebagai ekspresi tabel umum rekursif (CTE)) tidak digunakan di BigQuery. Fungsi tersebut dapat ditulis ulang menggunakan array `UNION ALL`.

Pernyataan flow-of-control berikut tidak digunakan di BigQuery karena BigQuery tidak menggunakan kursor atau sesi:

FOR var AS SELECT ... DO stmts END FOR;
FOR var AS cur CURSOR FOR SELECT ... DO stmts END FOR;

Pernyataan SQL transaksi dan metadata

Teradata	BigQuery
`HELP TABLE table_name;` `HELP VIEW view_name;`	`SELECT * EXCEPT(is_generated, generation_expression, is_stored, is_updatable) FROM mydataset.INFORMATION_SCHEMA.COLUMNS; WHERE table_name=table_name` Kueri yang sama valid untuk mendapatkan informasi kolom untuk tampilan. Untuk mengetahui informasi selengkapnya, lihat Tampilan kolom di `INFORMATION_SCHEMA` BigQuery.
`SELECT * FROM dbc.tables WHERE tablekind = 'T';` (tampilan DBC Teradata)	`SELECT * EXCEPT(is_typed) FROM mydataset.INFORMATION_SCHEMA.TABLES;` Untuk mengetahui informasi selengkapnya, lihat Pengantar `INFORMATION_SCHEMA` BigQuery.
`HELP STATISTICS table_name;`	`APPROX_COUNT_DISTINCT(col)`
`COLLECT STATS USING SAMPLE ON table_name column (...);`	Tidak digunakan di BigQuery.
`LOCKING TABLE table_name FOR EXCLUSIVE;`	BigQuery selalu menggunakan snapshot isolation. Untuk mengetahui detailnya, lihat Jaminan konsistensi di bagian lain dalam dokumen ini.
`SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL ...`	BigQuery selalu menggunakan Snapshot Isolation. Untuk mengetahui detailnya, lihat Jaminan konsistensi di bagian lain dalam dokumen ini.
`BEGIN TRANSACTION; SELECT ... END TRANSACTION;`	BigQuery selalu menggunakan Snapshot Isolation. Untuk mengetahui detailnya, lihat Jaminan konsistensi di bagian lain dalam dokumen ini.
`EXPLAIN ...`	Tidak digunakan di BigQuery. Fitur serupa adalah penjelasan paket kueri di UI web BigQuery dan alokasi slot yang terlihat di tampilan `INFORMATION_SCHEMA` dan di log audit di Cloud Monitoring.

Pernyataan SQL multi-pernyataan dan multi-baris

Teradata dan BigQuery mendukung transaksi (sesi) sehingga mendukung pernyataan yang dipisahkan oleh titik koma yang dijalankan bersama secara konsisten. Untuk informasi selengkapnya, lihat Transaksi multi-pernyataan.

Kode dan pesan error

Kode error Teradata dan kode error BigQuery berbeda. BigQuery menyediakan REST API dan terutama mengandalkan kode status HTTP serta pesan error yang mendetail.

Jika logika aplikasi Anda saat ini menemukan error berikut, cobalah untuk menghapus sumber error, karena BigQuery tidak akan menampilkan kode error yang sama.

SQLSTATE = '02000'—"Baris tidak ditemukan"
SQLSTATE = '21000'—"Pelanggaran kardinalitas (Indeks Unik)"
SQLSTATE = '22000'—"Pelanggaran data (Jenis Data)"
SQLSTATE = '23000'—"Pelanggaran Batasan"

Di BigQuery, akan lebih umum untuk menggunakan tampilan INFORMATION_SCHEMA atau log audit untuk melihat perincian error.

Untuk informasi tentang cara menangani kesalahan dalam Pembuatan skrip, lihat bagian berikut ini.

Jaminan konsistensi dan transaction isolation

Teradata 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 dan diperbarui.

Transaksi

Teradata menyediakan Baca yang Tidak Di-commit (memungkinkan pembacaan kotor) atau Transaksi serialisasi tingkat isolasi saat berjalan dalam mode sesi (bukan mode commit otomatis). Dalam kasus terbaik, Teradata mencapai isolasi serialisasi secara ketat dengan menggunakan penguncian pesimis terhadap hash baris di semua kolom baris di semua partisi. Deadlock dapat terjadi. DDL selalu memaksakan batas transaksi. Tugas Fastload Teradata berjalan secara independen, tetapi hanya pada tabel kosong.

BigQuery juga mendukung transaksi. BigQuery membantu memastikan kontrol konkurensi optimis (yang pertama kali di-commit) dengan isolasi snapshot, di mana kueri membaca pesan terakhir yang di-commit data 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 pernyataan UPDATE berbeda dari tabel yang sama, BigQuery beralih ke kontrol konkurensi pesimis dan mengantrekan beberapa pernyataan UPDATE, yang secara otomatis mencoba kembali jika terjadi konflik. Pernyataan DML dan tugas pemuatan INSERT dapat berjalan secara serentak dan terpisah untuk ditambahkan ke tabel.

Rollback

Teradata mendukung mode rollback dua sesi, mode sesi ANSI, dan mode sesi Teradata (SET SESSION CHARACTERISTICS dan SET SESSION TRANSACTION), bergantung pada mode rollback yang Anda inginkan. Jika terjadi kegagalan, transaksi mungkin tidak di-roll back.

BigQuery mendukung pernyataan ROLLBACK TRANSACTION. Tidak ada pernyataan ABORT di BigQuery.

Batas database

Selalu periksa Dokumentasi publik BigQuery untuk mengetahui kuota dan batas terbaru. Banyak kuota untuk pengguna bervolume besar dapat ditambah dengan menghubungi tim Dukungan Cloud. Tabel berikut menunjukkan perbandingan batas database Teradata dan BigQuery.

Batas	Teradata	BigQuery
Tabel per database	Tidak dibatasi	Tidak dibatasi
Kolom per tabel	2.048	10.000
Ukuran baris maksimum	1 MB	100 MB
Panjang nama tabel dan kolom	128 karakter Unicode	16.384 karakter Unicode
Baris per tabel	Tak terbatas	Tak terbatas
Panjang permintaan SQL maksimum	1 MB	1 MB (panjang kueri GoogleSQL maksimum yang belum terselesaikan) 12 MB (panjang maksimum kueri GoogleSQL dan lama yang diselesaikan) Streaming: 10 MB (batas ukuran permintaan HTTP) 10.000 (baris maksimum per permintaan)
Ukuran permintaan dan respons maksimum	7 MB (permintaan), 16 MB (respons)	10 MB (permintaan) dan 10 GB (respons), atau hampir tidak terbatas jika Anda menggunakan penomoran halaman atau Cloud Storage API.
Jumlah maksimum sesi konkuren	120 per mesin penguraian (PE)	100 kueri konkuren (dapat diajukan dengan pemesanan slot), 300 permintaan API konkuren per pengguna.
Jumlah maksimum pemuatan konkuren (cepat)	30 (default 5)	Tidak ada batas permintaan konkurensi; pekerjaan dimasukkan ke dalam antrean. 100.000 tugas pemuatan per project per hari.

Panduan penerjemahan SQL Teradata

Jenis data

Pemformatan jenis teradata

Pemformatan jenis tanggal dan stempel waktu

Sintaksis kueri

Pernyataan SELECT

Operator perbandingan

Kondisi JOIN

Konversi jenis dan casting

Klausa QUALIFY, ROWS

Kata kunci NORMALIZE

Functions

Fungsi agregat

Fungsi analisis dan fungsi jendela

Fungsi tanggal/waktu

Fungsi string

Fungsi matematika

Sintaksis DML

Pernyataan INSERT

Pernyataan UPDATE

Pernyataan DELETE dan TRUNCATE

Pernyataan MERGE

Variabel yang terpengaruh baris

Sintaksis DDL

Pernyataan CREATE TABLE

Opsi dan atribut kolom

Tabel sementara

Pernyataan CREATE VIEW

Pernyataan CREATE [UNIQUE] INDEX

Pengindeksan untuk performa

Pengindeksan untuk konsistensi (UNIQUE, PRIMARY INDEX)

Pengindeksan untuk mencapai penguncian

Pernyataan SQL prosedural

Pernyataan CREATE PROCEDURE

Deklarasi dan penetapan variabel

Pengendali kondisi error

Deklarasi dan operasi kursor

Pernyataan SQL dinamis

Pernyataan flow-of-control

Pernyataan SQL transaksi dan metadata

Pernyataan SQL multi-pernyataan dan multi-baris

Kode dan pesan error

Jaminan konsistensi dan transaction isolation

Transaksi

Rollback

Batas database

Pernyataan `SELECT`

Kondisi `JOIN`

Klausa `QUALIFY`, `ROWS`

Kata kunci `NORMALIZE`

Pernyataan `INSERT`

Pernyataan `UPDATE`

Pernyataan `DELETE` dan `TRUNCATE`

Pernyataan `MERGE`

Pernyataan `CREATE TABLE`

Pernyataan `CREATE VIEW`

Pernyataan `CREATE [UNIQUE] INDEX`

Pernyataan `CREATE PROCEDURE`