Halaman ini diterjemahkan oleh Cloud Translation API.

Panduan penerjemahan Oracle SQL

Dokumen ini menjelaskan persamaan dan perbedaan sintaksis SQL antara Oracle 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 antara jenis data di Oracle dan di BigQuery.

Oracle	BigQuery	Catatan
`VARCHAR2`	`STRING`
`NVARCHAR2`	`STRING`
`CHAR`	`STRING`
`NCHAR`	`STRING`
`CLOB`	`STRING`
`NCLOB`	`STRING`
`INTEGER`	`INT64`
`SHORTINTEGER`	`INT64`
`LONGINTEGER`	`INT64`
`NUMBER`	`NUMERIC`	BigQuery tidak mengizinkan pengguna menentukan nilai kustom untuk presisi atau skala. Akibatnya, kolom di Oracle dapat ditentukan sehingga memiliki skala yang lebih besar daripada yang didukung BigQuery. Selain itu, sebelum menyimpan angka desimal, Oracle akan membulatkan ke atas jika angka tersebut memiliki lebih banyak digit setelah koma desimal daripada yang ditentukan untuk kolom yang sesuai. Di BigQuery, fitur ini dapat diterapkan menggunakan fungsi `ROUND()`.
`NUMBER(*, x)`	`NUMERIC`	BigQuery tidak mengizinkan pengguna menentukan nilai kustom untuk presisi atau skala. Akibatnya, kolom di Oracle dapat ditentukan sehingga memiliki skala yang lebih besar daripada yang didukung BigQuery. Selain itu, sebelum menyimpan angka desimal, Oracle akan membulatkan ke atas jika angka tersebut memiliki lebih banyak digit setelah koma desimal daripada yang ditentukan untuk kolom yang sesuai. Di BigQuery, fitur ini dapat diterapkan menggunakan fungsi `ROUND()`.
`NUMBER(x, -y)`	`INT64`	Jika pengguna mencoba menyimpan angka desimal, Oracle akan membulatkan ke bilangan bulat. Untuk BigQuery, upaya untuk menyimpan angka desimal di kolom yang ditentukan sebagai `INT64` akan menghasilkan error. Dalam hal ini, fungsi `ROUND()` harus diterapkan. Jenis data `INT64` BigQuery memungkinkan presisi hingga 18 digit. Jika kolom angka memiliki lebih dari 18 digit, jenis data `FLOAT64` harus digunakan di BigQuery.
`NUMBER(x)`	`INT64`	Jika pengguna mencoba menyimpan angka desimal, Oracle akan membulatkan ke bilangan bulat. Untuk BigQuery, upaya untuk menyimpan angka desimal di kolom yang ditentukan sebagai `INT64` akan menghasilkan error. Dalam hal ini, fungsi `ROUND()` harus diterapkan. Jenis data `INT64` BigQuery memungkinkan presisi hingga 18 digit. Jika kolom angka memiliki lebih dari 18 digit, jenis data `FLOAT64` harus digunakan di BigQuery.
`FLOAT`	`FLOAT64`/`NUMERIC`	`FLOAT` adalah jenis data pasti, dan merupakan subjenis `NUMBER` di Oracle. Di BigQuery, `FLOAT64` adalah jenis data perkiraan. `NUMERIC` mungkin lebih cocok untuk jenis `FLOAT` di BigQuery.
`BINARY_DOUBLE`	`FLOAT64`/`NUMERIC`	`FLOAT` adalah jenis data pasti, dan merupakan subjenis `NUMBER` di Oracle. Di BigQuery, `FLOAT64` adalah jenis data perkiraan. `NUMERIC` mungkin lebih cocok untuk jenis `FLOAT` di BigQuery.
`BINARY_FLOAT`	`FLOAT64`/`NUMERIC`	`FLOAT` adalah jenis data pasti, dan merupakan subjenis `NUMBER` di Oracle. Di BigQuery, `FLOAT64` adalah jenis data perkiraan. `NUMERIC` mungkin lebih cocok untuk jenis `FLOAT` di BigQuery.
`LONG`	`BYTES`	Jenis data `LONG` digunakan di versi sebelumnya dan tidak disarankan di Oracle Database versi baru. Jenis data `BYTES` di BigQuery dapat digunakan jika diperlukan untuk menyimpan data `LONG` di BigQuery. Pendekatan yang lebih baik adalah menempatkan objek biner di Cloud Storage dan menyimpan referensi di BigQuery.
`BLOB`	`BYTES`	Jenis data `BYTES` dapat digunakan untuk menyimpan data biner dengan panjang variabel. Jika kolom ini tidak dikueri dan tidak digunakan dalam analisis, opsi yang lebih baik adalah menyimpan data biner di Cloud Storage.
`BFILE`	`STRING`	File biner dapat disimpan di Cloud Storage dan jenis data `STRING` dapat digunakan untuk mereferensikan file dalam tabel BigQuery.
`DATE`	`DATETIME`
`TIMESTAMP`	`TIMESTAMP`	BigQuery mendukung presisi mikrodetik (10^-6) dibandingkan dengan Oracle yang mendukung presisi mulai dari 0 hingga 9. BigQuery mendukung nama region zona waktu dari database TZ dan offset zona waktu dari UTC. Di BigQuery, konversi zona waktu harus dilakukan secara manual agar cocok dengan fitur `TIMESTAMP WITH LOCAL TIME ZONE` Oracle.
`TIMESTAMP(x)`	`TIMESTAMP`	BigQuery mendukung presisi mikrodetik (10^-6) dibandingkan dengan Oracle yang mendukung presisi mulai dari 0 hingga 9. BigQuery mendukung nama region zona waktu dari database TZ dan offset zona waktu dari UTC. Di BigQuery, konversi zona waktu harus dilakukan secara manual agar cocok dengan fitur `TIMESTAMP WITH LOCAL TIME ZONE` Oracle.
`TIMESTAMP WITH TIME ZONE`	`TIMESTAMP`	BigQuery mendukung presisi mikrodetik (10^-6) dibandingkan dengan Oracle yang mendukung presisi mulai dari 0 hingga 9. BigQuery mendukung nama region zona waktu dari database TZ dan offset zona waktu dari UTC. Di BigQuery, konversi zona waktu harus dilakukan secara manual agar cocok dengan fitur `TIMESTAMP WITH LOCAL TIME ZONE` Oracle.
`TIMESTAMP WITH LOCAL TIME ZONE`	`TIMESTAMP`	BigQuery mendukung presisi mikrodetik (10^-6) dibandingkan dengan Oracle yang mendukung presisi mulai dari 0 hingga 9. BigQuery mendukung nama region zona waktu dari database TZ dan offset zona waktu dari UTC. Di BigQuery, konversi zona waktu harus dilakukan secara manual agar cocok dengan fitur `TIMESTAMP WITH LOCAL TIME ZONE` Oracle.
`INTERVAL YEAR TO MONTH`	`STRING`	Nilai interval dapat disimpan sebagai jenis data `STRING` di BigQuery.
`INTERVAL DAY TO SECOND`	`STRING`	Nilai interval dapat disimpan sebagai jenis data `STRING` di BigQuery.
`RAW`	`BYTES`	Jenis data `BYTES` dapat digunakan untuk menyimpan data biner dengan panjang variabel. Jika kolom ini tidak dikueri dan digunakan dalam analisis, opsi yang lebih baik adalah menyimpan data biner di Cloud Storage.
`LONG RAW`	`BYTES`	Jenis data `BYTES` dapat digunakan untuk menyimpan data biner dengan panjang variabel. Jika kolom ini tidak dikueri dan digunakan dalam analisis, opsi yang lebih baik adalah menyimpan data biner di Cloud Storage.
`ROWID`	`STRING`	Jenis data ini digunakan Oracle secara internal untuk menentukan alamat unik ke baris dalam tabel. Umumnya, kolom `ROWID` atau `UROWID` tidak boleh digunakan dalam aplikasi. Namun, jika demikian, jenis data `STRING` dapat digunakan untuk menyimpan data ini.

Pemformatan jenis

Oracle SQL menggunakan serangkaian format default yang ditetapkan sebagai parameter untuk menampilkan ekspresi dan data kolom, serta untuk konversi di antara jenis data. Misalnya, NLS_DATE_FORMAT menetapkan format tanggal YYYY/MM/DD sebagai YYYY/MM/DD secara default. Anda dapat menemukan informasi selengkapnya tentang setelan NLS di dokumentasi online Oracle. Di BigQuery, tidak ada parameter inisialisasi.

Secara default, BigQuery mengharapkan semua data sumber dienkode UTF-8 saat dimuat. Secara opsional, jika memiliki file CSV dengan data yang dienkode dalam format ISO-8859-1, Anda dapat menentukan secara eksplisit encoding saat mengimpor data sehingga BigQuery dapat mengonversi data Anda ke UTF-8 dengan benar selama proses impor.

Anda hanya dapat mengimpor data yang berenkode ISO-8859-1 atau UTF-8. BigQuery menyimpan dan menampilkan data sebagai berenkode UTF-8. Format tanggal atau zona waktu yang diinginkan dapat ditetapkan dalam fungsi DATE dan TIMESTAMP.

Pemformatan jenis tanggal dan stempel waktu

Saat mengonversi elemen stempel waktu dan pemformatan tanggal dari Oracle ke BigQuery, Anda harus memperhatikan perbedaan zona waktu antara TIMESTAMP dan DATETIME seperti yang diringkas dalam tabel berikut.

Perhatikan bahwa tidak ada tanda kurung dalam format Oracle karena format (CURRENT_*) adalah kata kunci, bukan fungsi.

Oracle	BigQuery	Catatan
`CURRENT_TIMESTAMP`	Informasi `TIMESTAMP` di Oracle dapat memiliki informasi zona waktu yang berbeda, yang ditentukan menggunakan `WITH TIME ZONE` dalam definisi kolom atau variabel setelan `TIME_ZONE`.	Jika memungkinkan, gunakan fungsi `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. Dalam alat command line BigQuery dan konsol BigQuery, `DATETIME` diformat menggunakan pemisah `T` sesuai dengan RFC 3339. Namun, dalam Python dan Java JDBC, spasi digunakan sebagai pemisah. Jika Anda ingin menggunakan format eksplisit, gunakan fungsi `FORMAT_DATETIME`(), yang membuat string menjadi transmisi eksplisit. Misalnya, ekspresi berikut selalu menampilkan pemisah spasi: `CAST(CURRENT_DATETIME() AS STRING)`
`CURRENT_DATE SYSDATE`	Oracle menggunakan 2 jenis untuk tanggal: jenis 12 jenis 13 Oracle menggunakan jenis 12 saat menyimpan tanggal. Secara internal, ini adalah angka dengan panjang tetap. Oracle menggunakan jenis 13 saat a ditampilkan oleh `SYSDATE or CURRENT_DATE`	BigQuery memiliki format `DATE` terpisah yang selalu menampilkan tanggal dalam format ISO 8601. `DATE_FROM_UNIX_DATE` tidak dapat digunakan karena berbasis tahun 1970.
`CURRENT_DATE-3`	Nilai tanggal direpresentasikan sebagai bilangan bulat. Oracle 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`.
`NLS_DATE_FORMAT`	Tetapkan format sesi atau tanggal sistem.	BigQuery selalu menggunakan ISO 8601, jadi pastikan Anda mengonversi tanggal dan waktu Oracle.

Sintaksis kueri

Bagian ini membahas perbedaan sintaksis kueri antara Oracle dan BigQuery.

Pernyataan `SELECT`

Sebagian besar pernyataan SELECT Oracle kompatibel dengan BigQuery.

Fungsi, operator, dan ekspresi

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

Operator perbandingan

Operator perbandingan Oracle dan BigQuery mematuhi ANSI SQL:2011. Operator perbandingan pada tabel di bawah ini sama di BigQuery dan Oracle. Anda dapat menggunakan REGEXP_CONTAINS, bukan REGEXP_LIKE di BigQuery.

Operator	Deskripsi
`"="`	Sama dengan
`<>`	Tidak sama dengan
`!=`	Tidak sama dengan
`>`	Lebih dari
`>=`	Lebih dari atau sama dengan
`<`	Kurang dari
`<=`	Kurang dari atau sama dengan
`IN ( )`	Mencocokkan nilai dalam daftar
`NOT`	Mengabaikan kondisi
`BETWEEN`	Dalam rentang (inklusif)
`IS NULL`	`NULL` nilai
`IS NOT NULL`	Bukan nilai `NULL`
`LIKE`	Pencocokan pola dengan %
`EXISTS`	Kondisi terpenuhi jika subkueri menampilkan minimal satu baris

Operator pada tabel di BigQuery dan Oracle sama.

Fungsi dan ekspresi logika

Oracle	BigQuery
`CASE`	`CASE`
`COALESCE`	`COALESCE(expr1, ..., exprN)`
`DECODE`	`CASE.. WHEN.. END`
`NANVL`	`IFNULL`
`FETCH NEXT>`	`LIMIT`
`NULLIF`	`NULLIF(expression, expression_to_match)`
`NVL`	`IFNULL(expr, 0), COALESCE(exp, 0)`
`NVL2`	`IF(expr, true_result, else_result)`

Fungsi agregat

Tabel berikut menunjukkan pemetaan antara agregat Oracle umum, agregat statistik, dan fungsi agregat perkiraan dengan BigQuery yang setara:

Oracle	BigQuery
`ANY_VALUE` (dari Oracle 19c)	`ANY_VALUE`
`APPROX_COUNT`	`HLL_COUNT set of functions with specified precision`
`APPROX_COUNT_DISTINCT`	`APPROX_COUNT_DISTINCT`
`APPROX_COUNT_DISTINCT_AGG`	`APPROX_COUNT_DISTINCT`
`APPROX_COUNT_DISTINCT_DETAIL`	`APPROX_COUNT_DISTINCT`
`APPROX_PERCENTILE(percentile) WITHIN GROUP (ORDER BY expression)`	`APPROX_QUANTILES(expression, 100)[ OFFSET(CAST(TRUNC(percentile * 100) as INT64))]` BigQuery tidak mendukung argumen lainnya yang ditentukan Oracle.
<codeAPPROX_PERCENTILE_AGG	`APPROX_QUANTILES(expression, 100)[ OFFSET(CAST(TRUNC(percentile * 100) as INT64))]`
`APPROX_PERCENTILE_DETAIL`	`APPROX_QUANTILES(expression, 100)[OFFSET(CAST(TRUNC(percentile * 100) as INT64))]`
`APPROX_SUM`	`APPROX_TOP_SUM(expression, weight, number)`
`AVG`	`AVG`
`BIT_COMPLEMENT`	operator bukan bitwise: ~
`BIT_OR`	`BIT_OR, X \| Y`
`BIT_XOR`	`BIT_XOR, X ^ Y`
`BITAND`	`BIT_AND, X & Y`
`CARDINALITY`	`COUNT`
`COLLECT`	BigQuery tidak mendukung `TYPE AS TABLE OF`. Pertimbangkan untuk menggunakan `STRING_AGG()` atau `ARRAY_AGG()` di BigQuery
`CORR/CORR_K/` `CORR_S`	`CORR`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`FIRST`	Tidak ada secara implisit di BigQuery. Pertimbangkan untuk menggunakan fungsi yang ditentukan pengguna (UDF).
`GROUP_ID`	Tidak digunakan di BigQuery.
`GROUPING`	Tidak digunakan di BigQuery.
`GROUPING_ID`	Tidak digunakan di BigQuery.
`LAST`	Tidak ada secara implisit di BigQuery. Sebaiknya gunakan UDF.
`LISTAGG`	`STRING_AGG, ARRAY_CONCAT_AGG(expression [ORDER BY key [{ASC\|DESC}] [, ... ]] [LIMIT n])`
`MAX`	`MAX`
`MIN`	`MIN`
`OLAP_CONDITION`	Khusus Oracle, tidak ada di BigQuery.
`OLAP_EXPRESSION`	Khusus Oracle, tidak ada di BigQuery.
`OLAP_EXPRESSION_BOOL`	Khusus Oracle, tidak ada di BigQuery.
`OLAP_EXPRESSION_DATE`	Khusus Oracle, tidak ada di BigQuery.
`OLAP_EXPRESSION_TEXT`	Khusus Oracle, tidak ada di BigQuery.
`OLAP_TABLE`	Khusus Oracle, tidak ada di BigQuery.
`POWERMULTISET`	Khusus Oracle, tidak ada di BigQuery.
`POWERMULTISET_BY_CARDINALITY`	Khusus Oracle, tidak ada di BigQuery.
`QUALIFY`	Khusus Oracle, tidak ada di BigQuery.
`REGR_AVGX`	`AVG(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, ind_var_expr)` `)`
`REGR_AVGY`	`AVG(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, dep_var_expr)` `)`
`REGR_COUNT`	`SUM(` `IF(dep_var_expr is NULL` `OR ind_var_expr is NULL,` `NULL, 1)` `)`
`REGR_INTERCEPT`	`AVG(dep_var_expr) - AVG(ind_var_expr) * (COVAR_SAMP(ind_var_expr,dep_var_expr) / VARIANCE(ind_var_expr) )`
`REGR_R2`	`(COUNT(dep_var_expr) * SUM(ind_var_expr * dep_var_expr) - SUM(dep_var_expr) * SUM(ind_var_expr)) / SQRT( (COUNT(ind_var_expr) * SUM(POWER(ind_var_expr, 2)) * POWER(SUM(ind_var_expr),2)) * (COUNT(dep_var_expr) * SUM(POWER(dep_var_expr, 2)) * POWER(SUM(dep_var_expr), 2)))`
`REGR_SLOPE`	`COVAR_SAMP(ind_var_expr,` `dep_var_expr)` `/ VARIANCE(ind_var_expr)`
`REGR_SXX`	`SUM(POWER(ind_var_expr, 2)) - COUNT(ind_var_expr) * POWER(AVG(ind_var_expr),2)`
`REGR_SXY`	`SUM(ind_var_exprdep_var_expr) - COUNT(ind_var_expr) AVG(ind) * AVG(dep_var_expr)`
`REGR_SYY`	`SUM(POWER(dep_var_expr, 2)) - COUNT(dep_var_expr) * POWER(AVG(dep_var_expr),2)`
`ROLLUP`	`ROLLUP`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`
`WM_CONCAT`	`STRING_AGG`

BigQuery menawarkan fungsi agregat tambahan berikut:

Fungsi analisis

Tabel berikut menunjukkan pemetaan antara fungsi analisis agregat dan Oracle umum dengan BigQuery yang setara.

Oracle	BigQuery
`AVG`	`AVG`
`BIT_COMPLEMENT`	operator bukan bitwise: ~
`BIT_OR`	`BIT_OR, X \| Y`
`BIT_XOR`	`BIT_XOR, X ^ Y`
`BITAND`	`BIT_AND, X & Y`
`BOOL_TO_INT`	`CAST(X AS INT64)`
`COUNT`	`COUNT`
`COVAR_POP`	`COVAR_POP`
`COVAR_SAMP`	`COVAR_SAMP`
`CUBE_TABLE`	Tidak didukung di BigQuery. Pertimbangkan untuk menggunakan alat BI atau UDF kustom
`CUME_DIST`	`CUME_DIST`
`DENSE_RANK(ANSI)`	`DENSE_RANK`
`FEATURE_COMPARE`	Tidak ada secara implisit di BigQuery. Pertimbangkan untuk menggunakan UDF dan BigQuery ML
`FEATURE_DETAILS`	Tidak ada secara implisit di BigQuery. Pertimbangkan untuk menggunakan UDF dan BigQuery ML
`FEATURE_ID`	Tidak ada secara implisit di BigQuery. Pertimbangkan untuk menggunakan UDF dan BigQuery ML
`FEATURE_SET`	Tidak ada secara implisit di BigQuery. Pertimbangkan untuk menggunakan UDF dan BigQuery ML
`FEATURE_VALUE`	Tidak ada secara implisit di BigQuery. Pertimbangkan untuk menggunakan UDF dan BigQuery ML
`FIRST_VALUE`	`FIRST_VALUE`
`HIER_CAPTION`	Kueri hierarkis tidak didukung di BigQuery.
`HIER_CHILD_COUNT`	Kueri hierarkis tidak didukung di BigQuery.
`HIER_COLUMN`	Kueri hierarkis tidak didukung di BigQuery.
`HIER_DEPTH`	Kueri hierarkis tidak didukung di BigQuery.
`HIER_DESCRIPTION`	Kueri hierarkis tidak didukung di BigQuery.
`HIER_HAS_CHILDREN`	Kueri hierarkis tidak didukung di BigQuery.
`HIER_LEVEL`	Kueri hierarkis tidak didukung di BigQuery.
`HIER_MEMBER_NAME`	Kueri hierarkis tidak didukung di BigQuery.
`HIER_ORDER`	Kueri hierarkis tidak didukung di BigQuery.
`HIER_UNIQUE_MEMBER_NAME`	Kueri hierarkis tidak didukung di BigQuery.
`LAST_VALUE`	`LAST_VALUE`
`LAG`	`LAG`
`LEAD`	`LEAD`
`LISTAGG`	`ARRAY_AGG STRING_AGG ARRAY_CONCAT_AGG`
`MATCH_NUMBER`	Pengenalan dan penghitungan pola dapat dilakukan dengan ekspresi reguler dan UDF di BigQuery
`MATCH_RECOGNIZE`	Pengenalan dan penghitungan pola dapat dilakukan dengan ekspresi reguler dan UDF di BigQuery
`MAX`	`MAX`
`MEDIAN`	`PERCENTILE_CONT(x, 0.5 RESPECT NULLS) OVER()`
`MIN`	`MIN`
`NTH_VALUE`	`NTH_VALUE (value_expression, constant_integer_expression [{RESPECT \| IGNORE} NULLS])`
`NTILE`	`NTILE(constant_integer_expression)`
`PERCENT_RANK PERCENT_RANKM`	`PERCENT_RANK`
`PERCENTILE_CONT PERCENTILE_DISC`	`PERCENTILE_CONT`
`PERCENTILE_CONT PERCENTILE_DISC`	`PERCENTILE_DISC`
`PRESENTNNV`	Khusus Oracle, tidak ada di BigQuery.
`PRESENTV`	Khusus Oracle, tidak ada di BigQuery.
`PREVIOUS`	Khusus Oracle, tidak ada di BigQuery.
`RANK`(ANSI)	`RANK`
`RATIO_TO_REPORT(expr) OVER (partition clause)`	`expr / SUM(expr) OVER (partition clause)`
`ROW_NUMBER`	`ROW_NUMBER`
`STDDEV_POP`	`STDDEV_POP`
`STDDEV_SAMP`	`STDDEV_SAMP, STDDEV`
`SUM`	`SUM`
`VAR_POP`	`VAR_POP`
`VAR_SAMP`	`VAR_SAMP, VARIANCE`
`VARIANCE`	`VARIANCE()`
`WIDTH_BUCKET`	UDF dapat digunakan.

Fungsi tanggal/waktu

Tabel berikut menunjukkan pemetaan antara fungsi tanggal/waktu Oracle umum dan BigQuery yang setara.

Oracle	BigQuery
`ADD_MONTHS(date, integer)`	`DATE_ADD(date, INTERVAL integer MONTH),` Jika tanggal adalah `TIMESTAMP`, Anda dapat menggunakan `EXTRACT(DATE FROM TIMESTAMP_ADD(date, INTERVAL integer MONTH))`
`CURRENT_DATE`	`CURRENT_DATE`
`CURRENT_TIME`	`CURRENT_TIME`
`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP`
`DATE - k`	`DATE_SUB(date_expression, INTERVAL k DAY)`
`DATE + k`	`DATE_ADD(date_expression, INTERVAL k DAY)`
`DBTIMEZONE`	BigQuery tidak mendukung zona waktu database.
`EXTRACT`	`EXTRACT(DATE), EXTRACT(TIMESTAMP)`
`LAST_DAY`	`DATE_SUB( DATE_TRUNC( DATE_ADD( date_expression, INTERVAL 1 MONTH ), MONTH ), INTERVAL 1 DAY )`
`LOCALTIMESTAMP`	BigQuery tidak mendukung setelan zona waktu.
`MONTHS_BETWEEN`	`DATE_DIFF(date_expression, date_expression, MONTH)`
`NEW_TIME`	`DATE(timestamp_expression, time zone) TIME(timestamp, time zone) DATETIME(timestamp_expression, time zone)`
`NEXT_DAY`	`DATE_ADD( DATE_TRUNC( date_expression, WEEK(day_value) ), INTERVAL 1 WEEK )`
`SYS_AT_TIME_ZONE`	`CURRENT_DATE([time_zone])`
`SYSDATE`	`CURRENT_DATE()`
`SYSTIMESTAMP`	`CURRENT_TIMESTAMP()`
`TO_DATE`	`PARSE_DATE`
`TO_TIMESTAMP`	`PARSE_TIMESTAMP`
`TO_TIMESTAMP_TZ`	`PARSE_TIMESTAMP`
`TZ_OFFSET`	Tidak didukung di BigQuery. Pertimbangkan untuk menggunakan UDF kustom.
`WM_CONTAINS` `WM_EQUALS` `WM_GREATERTHAN` `WM_INTERSECTION` `WM_LDIFF` `WM_LESSTHAN` `WM_MEETS` `WM_OVERLAPS` `WM_RDIFF`	Titik tidak digunakan di BigQuery. UDF dapat digunakan untuk membandingkan dua titik.

BigQuery menawarkan fungsi tanggal/waktu tambahan berikut:

Fungsi string

Tabel berikut menunjukkan pemetaan antara fungsi string Oracle dan BigQuery yang setara:

Oracle	BigQuery
`ASCII`	`TO_CODE_POINTS(string_expr)[OFFSET(0)]`
`ASCIISTR`	BigQuery tidak mendukung UTF-16
`RAWTOHEX`	`TO_HEX`
`LENGTH`	`CHAR_LENGTH`
`LENGTH`	`CHARACTER_LENGTH`
`CHR`	`CODE_POINTS_TO_STRING( [mod(numeric_expr, 256)] )`
`COLLATION`	Tidak ada di BigQuery. BigQuery tidak mendukung COLLATE dalam DML
`COMPOSE`	Fungsi kustom yang ditentukan pengguna.
`CONCAT, (\|\| operator)`	`CONCAT`
`DECOMPOSE`	Fungsi kustom yang ditentukan pengguna.
`ESCAPE_REFERENCE (UTL_I18N)`	Tidak didukung di BigQuery. Pertimbangkan untuk menggunakan fungsi yang ditentukan pengguna.
`INITCAP`	`INITCAP`
`INSTR/INSTR2/INSTR4/INSTRB/INSTRC`	Fungsi kustom yang ditentukan pengguna.
`LENGTH/LENGTH2/LENGTH4/LENGTHB/LENGTHC`	`LENGTH`
`LOWER`	`LOWER`
`LPAD`	`LPAD`
`LTRIM`	`LTRIM`
`NLS_INITCAP`	Fungsi kustom yang ditentukan pengguna.
`NLS_LOWER`	`LOWER`
`NLS_UPPER`	`UPPER`
`NLSSORT`	Khusus Oracle, tidak ada di BigQuery.
`POSITION`	`STRPOS(string, substring)`
`PRINTBLOBTOCLOB`	Khusus Oracle, tidak ada di BigQuery.
`REGEXP_COUNT`	`ARRAY_LENGTH(REGEXP_EXTRACT_ALL(value, regex))`
`REGEXP_INSTR`	`STRPOS(source_string, REGEXP_EXTRACT(source_string, regexp_string))` Catatan: Menampilkan kemunculan pertama.
`REGEXP_REPLACE`	`REGEXP_REPLACE`
`REGEXP_LIKE`	`IF(REGEXP_CONTAINS,1,0)`
`REGEXP_SUBSTR`	`REGEXP_EXTRACT, REGEXP_EXTRACT_ALL`
`REPLACE`	`REPLACE`
`REVERSE`	`REVERSE`
`RIGHT`	`SUBSTR(source_string, -1, length)`
`RPAD`	`RPAD`
`RTRIM`	`RTRIM`
`SOUNDEX`	Tidak didukung di BigQuery. Pertimbangkan untuk menggunakan UDF kustom
`STRTOK`	`SPLIT(instring, delimiter)[ORDINAL(tokennum)]` `Note: The entire delimiter string argument is used as a single delimiter. The default delimiter is a comma.`
`SUBSTR/SUBSTRB/SUBSTRC/SUBSTR2/SUBSTR4`	`SUBSTR`
`TRANSLATE`	`REPLACE`
`TRANSLATE USING`	`REPLACE`
`TRIM`	`TRIM`
`UNISTR`	`CODE_POINTS_TO_STRING`
`UPPER`	`UPPER`
`\|\|` (BAR VERTIKAL)	`CONCAT`

BigQuery menawarkan fungsi string tambahan berikut:

Fungsi matematika

Tabel berikut menunjukkan pemetaan antara fungsi matematika Oracle dan BigQuery yang setara.

Oracle	BigQuery
`ABS`	`ABS`
`ACOS`	`ACOS`
`ACOSH`	`ACOSH`
`ASIN`	`ASIN`
`ASINH`	`ASINH`
`ATAN`	`ATAN`
`ATAN2`	`ATAN2`
`ATANH`	`ATANH`
`CEIL`	`CEIL`
`CEILING`	`CEILING`
`COS`	`COS`
`COSH`	`COSH`
`EXP`	`EXP`
`FLOOR`	`FLOOR`
`GREATEST`	`GREATEST`
`LEAST`	`LEAST`
`LN`	`LN`
`LNNVL`	gunakan dengan `ISNULL`
`LOG`	`LOG`
`MOD (% operator)`	`MOD`
`POWER (** operator)`	`POWER, POW`
`DBMS_RANDOM.VALUE`	`RAND`
`RANDOMBYTES`	Tidak didukung di BigQuery. Pertimbangkan untuk menggunakan fungsi RAND dan UDF kustom
`RANDOMINTEGER`	`CAST(FLOOR(10*RAND()) AS INT64)`
`RANDOMNUMBER`	Tidak didukung di BigQuery. Pertimbangkan untuk menggunakan fungsi RAND dan UDF kustom
`REMAINDER`	`MOD`
`ROUND`	`ROUND`
`ROUND_TIES_TO_EVEN`	`ROUND()`
`SIGN`	`SIGN`
`SIN`	`SIN`
`SINH`	`SINH`
`SQRT`	`SQRT`
`STANDARD_HASH`	`FARM_FINGERPRINT, MD5, SHA1, SHA256, SHA512`
`STDDEV`	STDDEV
`TAN`	`TAN`
`TANH`	`TANH`
`TRUNC`	`TRUNC`
`NVL`	`IFNULL(expr, 0), COALESCE(exp, 0)`

BigQuery menawarkan fungsi matematika tambahan berikut:

Fungsi konversi jenis

Tabel berikut menunjukkan pemetaan antara fungsi konversi jenis Oracle dan BigQuery yang setara.

Oracle	BigQuery
`BIN_TO_NUM`	`SAFE_CONVERT_BYTES_TO_STRING(value)` `CAST(x AS INT64)`
`BINARY2VARCHAR`	`SAFE_CONVERT_BYTES_TO_STRING(value)`
`CAST CAST_FROM_BINARY_DOUBLE CAST_FROM_BINARY_FLOAT CAST_FROM_BINARY_INTEGER CAST_FROM_NUMBER CAST_TO_BINARY_DOUBLE CAST_TO_BINARY_FLOAT CAST_TO_BINARY_INTEGER CAST_TO_NUMBER CAST_TO_NVARCHAR2 CAST_TO_RAW >CAST_TO_VARCHAR`	`CAST(expr AS typename)`
`CHARTOROWID`	Oracle khusus tidak diperlukan.
`CONVERT`	BigQuery tidak mendukung himpunan karakter. Pertimbangkan untuk menggunakan fungsi kustom yang ditentukan pengguna.
`EMPTY_BLOB`	`BLOB` tidak digunakan di BigQuery.
`EMPTY_CLOB`	`CLOB` tidak digunakan di BigQuery.
`FROM_TZ`	Jenis dengan zona waktu tidak didukung di BigQuery. Pertimbangkan untuk menggunakan fungsi yang ditentukan pengguna dan FORMAT_TIMESTAMP
`INT_TO_BOOL`	`CAST`
`IS_BIT_SET`	Tidak ada secara implisit di BigQuery. Pertimbangkan untuk menggunakan UDF
`NCHR`	UDF dapat digunakan untuk mendapatkan karakter yang setara dengan biner
`NUMTODSINTERVAL`	Jenis data `INTERVAL` tidak didukung di BigQuery
`NUMTOHEX`	Tidak didukung di BigQuery. Pertimbangkan untuk menggunakan fungsi `TO_HEX` dan UDF kustom
`NUMTOHEX2`
`NUMTOYMINTERVAL`	Jenis data `INTERVAL` tidak didukung di BigQuery.
`RAW_TO_CHAR`	Khusus Oracle, tidak ada di BigQuery.
`RAW_TO_NCHAR`	Khusus Oracle, tidak ada di BigQuery.
`RAW_TO_VARCHAR2`	Khusus Oracle, tidak ada di BigQuery.
`RAWTOHEX`	Khusus Oracle, tidak ada di BigQuery.
`RAWTONHEX`	Khusus Oracle, tidak ada di BigQuery.
`RAWTONUM`	Khusus Oracle, tidak ada di BigQuery.
`RAWTONUM2`	Khusus Oracle, tidak ada di BigQuery.
`RAWTOREF`	Khusus Oracle, tidak ada di BigQuery.
`REFTOHEX`	Khusus Oracle, tidak ada di BigQuery.
`REFTORAW`	Khusus Oracle, tidak ada di BigQuery.
`ROWIDTOCHAR`	`ROWID` adalah jenis khusus Oracle dan tidak ada di BigQuery. Nilai ini harus direpresentasikan sebagai string.
`ROWIDTONCHAR`	`ROWID` adalah jenis khusus Oracle dan tidak ada di BigQuery. Nilai ini harus direpresentasikan sebagai string.
`SCN_TO_TIMESTAMP`	`SCN` adalah jenis khusus Oracle dan tidak ada di BigQuery. Nilai ini harus direpresentasikan sebagai stempel waktu.
`TO_ACLID TO_ANYLOB TO_APPROX_COUNT_DISTINCT TO_APPROX_PERCENTILE TO_BINARY_DOUBLE TO_BINARY_FLOAT TO_BLOB TO_CHAR TO_CLOB TO_DATE TO_DSINTERVAL TO_LOB TO_MULTI_BYTE TO_NCHAR TO_NCLOB TO_NUMBER TO_RAW TO_SINGLE_BYTE TO_TIME` TO_TIMESTAMP TO_TIMESTAMP_TZ TO_TIME_TZ TO_UTC_TIMEZONE_TZ TO_YMINTERVAL	`CAST(expr AS typename)` `PARSE_DATE` `PARSE_TIMESTAMP` Sintaksis transmisi digunakan dalam kueri untuk menunjukkan bahwa jenis hasil ekspresi harus dikonversi ke beberapa jenis lain.
`TREAT`	Khusus Oracle, tidak ada di BigQuery.
`VALIDATE_CONVERSION`	Tidak didukung di BigQuery. Pertimbangkan untuk menggunakan UDF kustom
`VSIZE`	Tidak didukung di BigQuery. Pertimbangkan untuk menggunakan UDF kustom

Fungsi JSON

Tabel berikut menunjukkan pemetaan antara fungsi JSON Oracle dan BigQuery yang setara.

Oracle	BigQuery
`AS_JSON`	`TO_JSON_STRING(value[, pretty_print])`
`JSON_ARRAY`	Pertimbangkan untuk menggunakan fungsi `TO_JSON_STRING` dan UDF
`JSON_ARRAYAGG`	Pertimbangkan untuk menggunakan fungsi `TO_JSON_STRING` dan UDF
`JSON_DATAGUIDE`	Fungsi kustom yang ditentukan pengguna.
`JSON_EQUAL`	Fungsi kustom yang ditentukan pengguna.
`JSON_EXIST`	Sebaiknya gunakan UDF dan `JSON_EXTRACT` atau `JSON_EXTRACT_SCALAR`
`JSON_MERGEPATCH`	Fungsi kustom yang ditentukan pengguna.
`JSON_OBJECT`	Tidak didukung oleh BigQuery.
`JSON_OBJECTAGG`	Tidak didukung oleh BigQuery.
`JSON_QUERY`	Sebaiknya gunakan UDF dan `JSON_EXTRACT` atau `JSON_EXTRACT_SCALAR`.
`JSON_TABLE`	Fungsi kustom yang ditentukan pengguna.
`JSON_TEXTCONTAINS`	Sebaiknya gunakan UDF dan `JSON_EXTRACT` atau `JSON_EXTRACT_SCALAR`.
`JSON_VALUE`	`JSON_EXTRACT_SCALAR`

Fungsi XML

BigQuery tidak menyediakan fungsi XML implisit. XML dapat dimuat ke BigQuery sebagai string dan UDF dapat digunakan untuk mengurai XML. Atau, pemrosesan XML dilakukan oleh alat ETL/ELT seperti Dataflow. Daftar berikut menunjukkan fungsi XML Oracle:

Oracle	BigQuery
`DELETEXML`	UDF atau alat ETL BigQuery seperti Dataflow dapat digunakan untuk memproses XML.
`ENCODE_SQL_XML`
`EXISTSNODE`
`EXTRACTCLOBXML`
`EXTRACTVALUE`
`INSERTCHILDXML`
`INSERTCHILDXMLAFTER`
`INSERTCHILDXMLBEFORE`
`INSERTXMLAFTER`
`INSERTXMLBEFORE`
`SYS_XMLAGG`
`SYS_XMLANALYZE`
`SYS_XMLCONTAINS`
`SYS_XMLCONV`
`SYS_XMLEXNSURI`
`SYS_XMLGEN`
`SYS_XMLI_LOC_ISNODE`
`SYS_XMLI_LOC_ISTEXT`
`SYS_XMLINSTR`
`SYS_XMLLOCATOR_GETSVAL`
`SYS_XMLNODEID`
`SYS_XMLNODEID_GETLOCATOR`
`SYS_XMLNODEID_GETOKEY`
`SYS_XMLNODEID_GETPATHID`
`SYS_XMLNODEID_GETPTRID`
`SYS_XMLNODEID_GETRID`
`SYS_XMLNODEID_GETSVAL`
`SYS_XMLT_2_SC`
`SYS_XMLTRANSLATE`
`SYS_XMLTYPE2SQL`
`UPDATEXML`
`XML2OBJECT`
`XMLCAST`
`XMLCDATA`
`XMLCOLLATVAL`
`XMLCOMMENT`
`XMLCONCAT`
`XMLDIFF`
`XMLELEMENT`
`XMLEXISTS`
`XMLEXISTS2`
`XMLFOREST`
`XMLISNODE`
`XMLISVALID`
`XMLPARSE`
`XMLPATCH`
`XMLPI`
`XMLQUERY`
`XMLQUERYVAL`
`XMLSERIALIZE`
`XMLTABLE`
`XMLTOJSON`
`XMLTRANSFORM`
`XMLTRANSFORMBLOB`
`XMLTYPE`

Fungsi machine learning

Fungsi machine learning (ML) di Oracle dan BigQuery berbeda. Oracle memerlukan paket analisis dan lisensi lanjutan untuk melakukan ML pada database. Oracle menggunakan paket DBMS_DATA_MINING untuk ML. Konversi tugas penambang data Oracle memerlukan penulisan ulang kode. Anda dapat memilih dari penawaran produk Google AI yang komprehensif seperti BigQuery ML, AI API (termasuk Speech-to-Text, Text-to-Speech , Dialogflow, Cloud Translation, NLP, Cloud Vision, dan Time series Insights API, AutoML, AutoML Tables atau AI Platform. Notebook yang dikelola pengguna Google dapat digunakan sebagai lingkungan pengembangan untuk data scientist dan Pelatihan AI Platform Google dapat digunakan untuk menjalankan pelatihan dan penskoran workload dalam skala besar. Tabel berikut menunjukkan fungsi Oracle ML:

Oracle	BigQuery
`CLASSIFIER`	Lihat BigQuery ML untuk mengetahui opsi regresi dan pengklasifikasi machine learning
`CLUSTER_DETAILS`
`CLUSTER_DISTANCE`
`CLUSTER_ID`
`CLUSTER_PROBABILITY`
`CLUSTER_SET`
`PREDICTION`
`PREDICTION_BOUNDS`
`PREDICTION_COST`
`PREDICTION_DETAILS`
`PREDICTION_PROBABILITY`
`PREDICTION_SET`

Fungsi keamanan

Tabel berikut menunjukkan fungsi untuk mengidentifikasi pengguna di Oracle dan BigQuery:

Oracle	BigQuery
`UID`	`SESSION_USER`
`USER/SESSION_USER/CURRENT_USER`	`SESSION_USER()`

Fungsi array atau set

Tabel berikut menunjukkan fungsi set atau array di Oracle dan yang setara di BigQuery:

Oracle	BigQuery
`MULTISET`	`ARRAY_AGG`
`MULTISET EXCEPT`	`ARRAY_AGG([DISTINCT] expression)`
`MULTISET INTERSECT`	`ARRAY_AGG([DISTINCT])`
`MULTISET UNION`	`ARRAY_AGG`

Fungsi jendela

Tabel berikut menunjukkan fungsi jendela di Oracle dan yang setara di BigQuery.

Oracle	BigQuery
`LAG`	`LAG (value_expression[, offset [, default_expression]])`
`LEAD`	`LEAD (value_expression[, offset [, default_expression]])`

Kueri hierarkis atau rekursif

Kueri hierarkis atau rekursif tidak digunakan di BigQuery. Jika kedalaman hierarki diketahui, fungsi serupa dapat dicapai dengan gabungan, seperti yang diilustrasikan dalam contoh berikut. Solusi lainnya adalah menggunakan BigQueryStorage API dan Spark.

select
  array(
    select e.update.element
    union all
    select c1 from e.update.element.child as c1
    union all
    select c2 from e.update.element.child as c1, c1.child as c2
    union all
    select c3 from e.update.element.child as c1, c1.child as c2, c2.child as c3
    union all
    select c4 from e.update.element.child as c1, c1.child as c2, c2.child as c3, c3.child as c4
    union all
    select c5 from e.update.element.child as c1, c1.child as c2, c2.child as c3, c3.child as c4, c4.child as c5
  ) as flattened,
  e as event
from t, t.events as e

Tabel berikut menunjukkan fungsi hierarkis di Oracle.

Oracle	BigQuery
`DEPTH`	Kueri hierarkis tidak digunakan di BigQuery.
`PATH`
`SYS_CONNECT_BY_PATH (hierarchical)`

Fungsi UTL

Paket UTL_File terutama digunakan untuk membaca dan menulis file sistem operasi dari PL/SQL. Cloud Storage dapat digunakan untuk semua jenis staging file mentah. Tabel eksternal serta pemuatan dan ekspor BigQuery harus digunakan untuk membaca dan menulis file dari dan ke Cloud Storage. Untuk informasi selengkapnya, lihat Pengantar sumber data eksternal.

Fungsi spasial

Anda dapat menggunakan analisis geospasial BigQuery untuk mengganti fungsi spasial. Terdapat beberapa fungsi dan jenis SDO_* di Oracle, seperti SDO_GEOM_KEY, SDO_GEOM_MBR, SDO_GEOM_MMB. Fungsi-fungsi ini digunakan untuk analisis spasial. Anda dapat menggunakan analisis geospasial untuk melakukan analisis spasial.

Sintaksis DML

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

Pernyataan `INSERT`

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

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

Oracle BigQuery

Oracle	BigQuery
`INSERT INTO table VALUES (...);`	`INSERT INTO table (...) VALUES (...);` Oracle 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 disertakan dalam urutan naik berdasarkan posisi ordinal-nya.
`INSERT INTO table VALUES (1,2,3); INSERT INTO table VALUES (4,5,6); INSERT INTO table VALUES (7,8,9); INSERT ALL INTO table (col1, col2) VALUES ('val1_1', 'val1_2') INTO table (col1, col2) VALUES ('val2_1', 'val2_2') INTO table (col1, col2) VALUES ('val3_1', 'val3_2') . . . SELECT 1 FROM DUAL;`	`INSERT INTO table VALUES (1,2,3), (4,5,6), (7,8,9);` 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 operasi `INSERT`. Menggabungkan beberapa pernyataan DML (termasuk `INSERT`) menggunakan pernyataan `MERGE`. Menggunakan `CREATE TABLE ... AS SELECT` untuk membuat dan mengisi tabel baru.

INSERT INTO table VALUES (...);

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

Oracle 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 disertakan dalam urutan naik berdasarkan posisi ordinal-nya.

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

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

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

    INSERT ALL

    INTO table (col1, col2) VALUES ('val1_1', 'val1_2')

    INTO table (col1, col2) VALUES ('val2_1', 'val2_2')

    INTO table (col1, col2) VALUES ('val3_1', 'val3_2')

    .

    .

    .

    SELECT 1 FROM DUAL;

INSERT INTO table VALUES (1,2,3),
(4,5,6),
(7,8,9);

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 operasi INSERT.
Menggabungkan beberapa pernyataan DML (termasuk INSERT) menggunakan pernyataan MERGE.
Menggunakan CREATE TABLE ... AS SELECT untuk membuat dan mengisi tabel baru.

Pernyataan `UPDATE`

Pernyataan UPDATE Oracle sebagian besar kompatibel dengan BigQuery, tetapi di BigQuery, pernyataan UPDATE harus memiliki klausa WHERE.

Sebagai praktik terbaik, Anda harus lebih memilih pernyataan DML batch daripada beberapa pernyataan UPDATE dan INSERT tunggal. Skrip DML di BigQuery memiliki semantik konsistensi yang sedikit berbeda dengan pernyataan yang setara di Oracle. Untuk ringkasan tentang snapshot isolation serta penanganan sesi dan transaksi, lihat bagian CREATE INDEX dalam dokumen ini.

Tabel berikut menunjukkan pernyataan UPDATE Oracle dan pernyataan BigQuery yang menyelesaikan tugas yang sama.

Di BigQuery, pernyataan UPDATE harus memiliki klausul WHERE. Untuk mengetahui informasi selengkapnya tentang UPDATE di BigQuery, lihat contoh UPDATE BigQuery dalam dokumentasi DML.

Pernyataan `DELETE` dan `TRUNCATE`

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

Di BigQuery, pernyataan DELETE harus memiliki klausa WHERE. Untuk mengetahui informasi selengkapnya tentang DELETE di BigQuery, lihat contoh DELETE BigQuery dalam dokumentasi DML.

Oracle	BigQuery
`DELETE database.table;`	`DELETE FROM table WHERE TRUE;`

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 Oracle mengikuti ANSI Syntax.

Namun, skrip DML di BigQuery memiliki semantik konsistensi yang sedikit berbeda dengan pernyataan yang setara di Oracle.

Sintaksis DDL

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

Pernyataan `CREATE TABLE`

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

STORAGE
TABLESPACE
DEFAULT
GENERATED ALWAYS AS
ENCRYPT
PRIMARY KEY (col, ...). Untuk informasi selengkapnya, lihat CREATE INDEX.
UNIQUE INDEX. Untuk informasi selengkapnya, lihat CREATE INDEX.
CONSTRAINT..REFERENCES
DEFAULT
PARALLEL
COMPRESS

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

Opsi dan atribut kolom

Kolom identitas diperkenalkan dengan versi Oracle 12c yang memungkinkan penambahan otomatis pada kolom. Ini tidak digunakan di BigQuery dan dapat dicapai dengan cara batch berikut. Untuk mengetahui informasi selengkapnya tentang kunci surrogate dan dimensi yang berubah secara perlahan (SCD), lihat panduan berikut:

Oracle	BigQuery
`CREATE TABLE table ( id NUMBER GENERATED ALWAYS AS IDENTITY, description VARCHAR2(30) );`	`INSERT INTO dataset.table SELECT *, ROW_NUMBER() OVER () AS id FROM dataset.table`

Komentar kolom

Oracle menggunakan sintaksis Comment untuk menambahkan komentar di kolom. Fitur ini dapat diterapkan secara serupa di BigQuery menggunakan deskripsi kolom seperti yang ditunjukkan dalam tabel berikut:

Oracle	BigQuery
`Comment on column table is 'column desc';`	`CREATE TABLE dataset.table ( col1 STRING OPTIONS(description="column desc") );`

Tabel sementara

Oracle mendukung tabel sementara, yang sering digunakan untuk menyimpan hasil perantara dalam skrip. Tabel sementara didukung di BigQuery.

Oracle	BigQuery
`CREATE GLOBAL TEMPORARY TABLE temp_tab (x INTEGER, y VARCHAR2(50)) ON COMMIT DELETE ROWS; COMMIT;`	`CREATE TEMP TABLE temp_tab ( x INT64, y STRING ); DELETE FROM temp_tab WHERE TRUE;`

Elemen Oracle berikut tidak digunakan di BigQuery:

ON COMMIT DELETE ROWS;
ON COMMIT PRESERVE ROWS;

Ada juga beberapa cara lain untuk mengemulasi tabel sementara di BigQuery:

TTL set data: Membuat set data yang memiliki waktu aktif singkat (misalnya, satu jam) sehingga setiap tabel yang dibuat dalam set data bersifat sementara (karena tidak akan bertahan lebih lama dari time to live (TTL) set data). Anda dapat memberikan awalan ke semua nama tabel dalam set data ini dengan temp untuk menunjukkan dengan jelas bahwa tabel tersebut bersifat sementara.

TTL Tabel: Membuat tabel yang memiliki time to live (TTL) 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.

Pernyataan `CREATE SEQUENCE`

Urutan tidak digunakan di BigQuery dan ini dapat dilakukan dengan cara batch berikut. Untuk mengetahui informasi selengkapnya tentang kunci surrogate dan dimensi yang berubah secara perlahan (SCD), lihat panduan berikut:

INSERT INTO dataset.table
    SELECT *,
      ROW_NUMBER() OVER () AS id
      FROM dataset.table

Pernyataan `CREATE VIEW`

Tabel berikut menunjukkan padanan antara Oracle dan BigQuery untuk pernyataan CREATE VIEW.

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

Pernyataan `CREATE MATERIALIZED VIEW`

Dalam operasi pemuatan ulang, tampilan terwujud BigQuery dilakukan secara otomatis. Anda tidak perlu menentukan opsi memuat ulang (misalnya, saat commit atau sesuai jadwal) di BigQuery. Untuk informasi selengkapnya, lihat Pengantar tampilan terwujud.

Jika tabel dasar terus berubah dengan menambahkan tambahan, kueri yang menggunakan tampilan terwujud (baik tampilan secara eksplisit direferensikan atau dipilih oleh pengoptimal kueri) akan memindai semua tampilan terwujud ditambah delta dalam tabel dasar sejak tampilan terakhir diperbarui. Artinya, kueri lebih cepat dan lebih murah.

Sebaliknya, jika ada pembaruan (DML UPDATE / GA) atau penghapusan (DML DELETE, pemotongan, akhir masa berlaku partisi) di tabel dasar sejak pemuatan ulang tampilan terakhir, tampilan terwujud tidak akan dipindai dan kueri tidak menghemat hingga tampilan berikutnya dimuat ulang. Pada dasarnya, pembaruan atau penghapusan dalam tabel dasar akan membatalkan status tampilan terwujud.

Selain itu, data dari buffering streaming tabel dasar tidak disimpan ke tampilan terwujud. Buffer streaming masih dipindai sepenuhnya terlepas dari apakah tampilan terwujud digunakan atau tidak.

Tabel berikut menunjukkan padanan antara Oracle dan BigQuery untuk pernyataan CREATE MATERIALIZED VIEW.

Oracle	BigQuery	Catatan
`CREATE MATERIALIZED VIEW view_name REFRESH FAST NEXT sysdate + 7 AS SELECT … FROM TABLE_1`	`CREATE MATERIALIZED VIEW view_name AS SELECT ...`

Pernyataan `CREATE [UNIQUE] INDEX`

Bagian ini menjelaskan pendekatan di BigQuery untuk cara membuat fungsionalitas yang mirip dengan indeks di Oracle.

Pengindeksan untuk performa

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

Pengindeksan untuk konsistensi (UNIQUE, PRIMARY INDEX)

Di Oracle, indeks unik dapat digunakan untuk mencegah baris dengan kunci tidak 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.

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 dengan izin edit dari menyisipkan data duplikat.

Untuk menghasilkan error pada data duplikat di BigQuery, Anda dapat menggunakan pernyataan MERGE dari tabel staging, seperti yang ditunjukkan pada contoh berikut:

Oracle		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());

Biasanya, pengguna lebih memilih untuk menghapus duplikat secara terpisah untuk menemukan error dalam sistem downstream.

BigQuery tidak mendukung kolom (urutan) DEFAULT dan IDENTITY.

Mengunci

BigQuery tidak memiliki mekanisme kunci seperti Oracle dan dapat menjalankan kueri serentak (hingga kuota Anda). Hanya pernyataan DML yang memiliki batas konkurensi tertentu dan mungkin memerlukan kunci tabel selama eksekusi dalam beberapa skenario.

Pernyataan SQL prosedural

Bagian ini menjelaskan cara mengonversi pernyataan SQL prosedural yang digunakan dalam prosedur, fungsi, dan pemicu tersimpan dari Oracle ke BigQuery.

Pernyataan `CREATE PROCEDURE`

Prosedur Tersimpan didukung sebagai bagian dari Skrip BigQuery versi Beta.

Oracle	BigQuery	Catatan
`CREATE PROCEDURE`	`CREATE PROCEDURE`	Serupa dengan Oracle, BigQuery mendukung mode argumen `IN, OUT, INOUT`. Spesifikasi sintaksis lainnya tidak didukung di BigQuery.
`CREATE OR REPLACE PROCEDURE`	`CREATE OR REPLACE PROCEDURE`
`CALL`	`CALL`

Bagian berikut ini menjelaskan cara mengonversi pernyataan prosedur Oracle yang ada menjadi pernyataan skrip BigQuery yang memiliki fungsi serupa.

Pernyataan `CREATE TRIGGER`

Pemicu tidak digunakan di BigQuery. Logika aplikasi berbasis baris harus ditangani pada lapisan aplikasi. Fungsi pemicu dapat dicapai dengan menggunakan alat penyerapan, fungsi Pub/Sub dan/atau Cloud Run selama waktu penyerapan atau menggunakan pemindaian reguler.

Deklarasi dan penetapan variabel

Tabel berikut menampilkan pernyataan DECLARE Oracle dan BigQuery yang setara.

Oracle	BigQuery
`DECLARE L_VAR NUMBER; BEGIN L_VAR := 10 + 20; END;`	`DECLARE L_VAR int64; BEGIN SET L_VAR = 10 + 20; SELECT L_VAR; END`
`SET var = value;`	`SET var = value;`

Deklarasi dan operasi kursor

BigQuery tidak mendukung kursor, sehingga pernyataan berikut tidak digunakan di BigQuery:

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

Pernyataan SQL dinamis

Pernyataan Oracle Dynamic SQL berikut dan BigQuery yang setara:

Oracle	BigQuery
`EXECUTE IMMEDIATE sql_str [USING IN OUT [, ...]];`	`EXECUTE IMMEDIATE sql_expression [INTO variable[, ...]] [USING identifier[, ...]]; ;`

Pernyataan flow-of-control

Tabel berikut menunjukkan pernyataan flow-of-control Oracle dan BigQuery yang setara.

Oracle	BigQuery
`IF condition THEN [if_statement_list] [ELSE else_statement_list ] END IF;`	`IF condition THEN [if_statement_list] [ELSE else_statement_list ] END IF;`
`SET SERVEROUTPUT ON; DECLARE x INTEGER DEFAULT 0; y INTEGER DEFAULT 0; BEGIN LOOP IF x>= 10 THEN EXIT; ELSIF x>= 5 THEN y := 5; END IF; x := x + 1; END LOOP; dbms_output.put_line(x\|\|','\|\|y); END; /`	`DECLARE x INT64 DEFAULT 0; DECLARE y INT64 DEFAULT 0; LOOP IF x>= 10 THEN LEAVE; ELSE IF x>= 5 THEN SET y = 5; END IF; END IF; SET x = x + 1; END LOOP; SELECT x,y;`
`LOOP sql_statement_list END LOOP;`	`LOOP sql_statement_list END LOOP;`
`WHILE boolean_expression DO sql_statement_list END WHILE;`	`WHILE boolean_expression DO sql_statement_list END WHILE;`
`FOR LOOP`	`FOR LOOP` tidak digunakan di BigQuery. Gunakan pernyataan `LOOP` lain.
`BREAK`	`BREAK`
`CONTINUE`	`CONTINUE`
`CONTINUE/EXIT WHEN`	Gunakan `CONTINUE` dengan kondisi `IF`.
`GOTO`	Pernyataan `GOTO` tidak ada di BigQuery. Gunakan kondisi `IF`.

Pernyataan SQL transaksi dan metadata

Oracle	BigQuery
`GATHER_STATS_JOB`	Belum digunakan di BigQuery.
`LOCK TABLE table_name IN [SHARE/EXCLUSIVE] MODE NOWAIT;`	Belum digunakan di BigQuery.
`Alter session set isolation_level=serializable; /` `SET TRANSACTION ...`	BigQuery selalu menggunakan Snapshot Isolation. Untuk mengetahui detailnya, lihat Jaminan konsistensi dan transaction isolation dalam dokumen ini.
`EXPLAIN PLAN ...`	Tidak digunakan di BigQuery. Fitur serupa adalah penjelasan rencana kueri di UI web BigQuery dan alokasi slot, serta dalam log audit di Stackdriver.
`SELECT * FROM DBA_[*];` (Tampilan DBA_/ALL_/V$ Oracle)	`SELECT * FROM mydataset.INFORMATION_SCHEMA.TABLES;` Untuk mengetahui informasi selengkapnya, lihat Pengantar INFORMATION_SCHEMA BigQuery.
`SELECT * FROM GV$SESSION;` `SELECT * FROM V$ACTIVE_SESSION_HISTORY;`	BigQuery tidak memiliki konsep sesi tradisional. Anda dapat melihat tugas kueri di UI atau mengekspor log audit stackdriver ke BigQuery dan menganalisis log BigQuery untuk menganalisis tugas. Untuk informasi selengkapnya, baca Melihat detail lowongan.
`START TRANSACTION;` `LOCK TABLE table_A IN EXCLUSIVE MODE NOWAIT;` `DELETE FROM table_A;` `INSERT INTO table_A SELECT * FROM table_B;` `COMMIT;`	Mengganti isi tabel dengan output kueri sama dengan mengganti transaksi. Anda dapat melakukannya dengan operasi kueri atau operasi salinan. Menggunakan kueri: `bq query --replace --destination_table table_A 'SELECT * FROM table_B';` Menggunakan salinan: `bq cp -f table_A table_B`

Pernyataan SQL multi-pernyataan dan multi-baris

Oracle 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 Oracle dan Kode error BigQuery berbeda. Jika logika aplikasi Anda saat ini menemukan error, cobalah untuk menghapus sumber error, karena BigQuery tidak menampilkan kode error yang sama.

Jaminan konsistensi dan transaction isolation

Oracle dan BigQuery bersifat atomik—yaitu, mematuhi ACID pada tingkat per mutasi di banyak baris. Misalnya, operasi MERGE bersifat atomik, bahkan dengan beberapa nilai yang disisipkan dan diperbarui.

Transaksi

Oracle menyediakan level isolasi transaksi yang di-commit atau dapat diserialisasi. Deadlock dapat terjadi. Tugas penambahan Oracle berjalan secara independen.

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

Oracle mendukung rollback. Karena tidak ada batas transaksi eksplisit di BigQuery, maka tidak ada konsep rollback eksplisit di BigQuery. Solusinya adalah dekorasi tabel atau menggunakan FOR SYSTEM_TIME AS OF.

Batas database

Lihat Kuota dan batas terbaru BigQuery. Banyak kuota untuk pengguna bervolume besar dapat ditambah dengan menghubungi Cloud Customer Care. Tabel berikut menunjukkan perbandingan batas database Oracle dan BigQuery.

Batas	Oracle	BigQuery
Tabel per database	Tidak dibatasi	Tidak dibatasi
Kolom per tabel	1000	10.000
Ukuran baris maksimum	Tidak terbatas (Tergantung jenis kolom)	100 MB
Panjang nama tabel dan kolom	Jika v12.2>= 128 Byte Lainnya, 30 Byte	16.384 karakter Unicode
Baris per tabel	Tak terbatas	Tak terbatas
Panjang permintaan SQL maksimum	Tak terbatas	1 MB (panjang kueri GoogleSQL maksimum yang belum terselesaikan) 12 MB (maksimum yang diselesaikan dan panjang kueri GoogleSQL lama) Streaming: 10 MB (batas ukuran permintaan HTTP) 10.000 (baris maksimum per permintaan)
Ukuran permintaan & respons maksimum	Tak terbatas	10 MB (permintaan) dan 10 GB (respons), atau hampir tidak terbatas jika Anda menggunakan penomoran halaman atau Cloud Storage API.
Jumlah maksimum sesi konkuren	Dibatasi oleh parameter sesi atau proses	100 kueri konkuren (dapat diajukan dengan pemesanan slot), 300 permintaan API konkuren per pengguna.
Jumlah maksimum pemuatan konkuren (cepat)	Dibatasi oleh parameter sesi atau proses	Tidak ada batas permintaan konkurensi; pekerjaan dimasukkan ke dalam antrean. 100.000 tugas pemuatan per project per hari.

Batas Oracle Database lainnya meliputi batas jenis data, batas database fisik, batas database logis, serta batas proses dan runtime.