Mengonversi dan mengoptimalkan kueri dari Oracle Database ke Cloud SQL untuk MySQL

Dokumen ini membahas perbedaan kueri dasar antara Oracle® dan Cloud SQL untuk MySQL, serta bagaimana fitur di Oracle dipetakan ke fitur di Cloud SQL untuk MySQL. Panduan ini juga menguraikan pertimbangan performa untuk Cloud SQL untuk MySQL dan cara menganalisis serta mengoptimalkan performa kueri di Google Cloud. Meskipun dokumen ini membahas teknik untuk mengoptimalkan prosedur dan pemicu yang tersimpan untuk Cloud SQL untuk MySQL, dokumen ini tidak membahas cara menerjemahkan kode PL/SQL ke prosedur dan fungsi yang tersimpan di MySQL.

Saat mengonversi kueri dari Oracle Database ke Cloud SQL untuk MySQL, ada perbedaan dialek SQL tertentu yang perlu dipertimbangkan. Ada juga beberapa fungsi bawaan yang berbeda atau tidak kompatibel antara kedua platform database tersebut.

Perbedaan kueri dasar

Meskipun Oracle dan Cloud SQL untuk MySQL mendukung ANSI SQL, ada beberapa perbedaan mendasar saat membuat kueri data, terutama seputar penggunaan fungsi sistem.

Tabel berikut menyoroti perbedaan sintaksis SELECT dan FROM untuk Oracle dan Cloud SQL untuk MySQL.

Nama fitur Oracle	Implementasi Oracle	Dukungan Cloud SQL untuk MySQL	Setara dengan Cloud SQL untuk MySQL
Sintaksis dasar SQL untuk pengambilan data	`SELECT` `FROM` `WHERE` `GROUP BY` `HAVING` `ORDER BY`	Ya	`SELECT` `FROM` `WHERE` `GROUP BY` `HAVING` `ORDER BY`
`SELECT` untuk cetak output	`SELECT 1 FROM DUAL`	Ya	`SELECT 1` atau `SELECT 1 FROM DUAL`
Alias kolom	`SELECT COL1 AS C1`	Ya	`SELECT COL1 AS C1` atau `SELECT COL1 C1`
Kepekaan huruf besar/kecil nama tabel	Tidak ada kepekaan huruf besar/kecil (misalnya, nama tabel dapat berupa `orders` dan `ORDERS`)	Tidak	Peka huruf besar/kecil sesuai dengan nama tabel yang ditentukan (misalnya, nama tabel hanya bisa `orders` atau `ORDERS`)

Tampilan inline

Tampilan inline (juga dikenal sebagai tabel turunan) adalah pernyataan SELECT, yang terletak di klausa FROM, dan digunakan sebagai subkueri. Tampilan inline dapat membantu menyederhanakan kueri yang kompleks dengan menghapus penghitungan gabungan atau menghilangkan operasi join, sekaligus menggabungkan beberapa kueri terpisah menjadi satu kueri yang disederhanakan.

Contoh berikut menguraikan contoh konversi dari Oracle 11g/12c ke Cloud SQL untuk MySQL untuk tampilan inline.

Tampilan inline di Oracle 11g/12c:

 SELECT FIRST_NAME,
            DEPARTMENT_ID,
            SALARY,
            DATE_COL
     FROM EMPLOYEES,
          (SELECT SYSDATE AS DATE_COL FROM DUAL);

Tampilan yang berfungsi di Cloud SQL untuk MySQL 5.7 dengan alias:

SELECT FIRST_NAME,
              DEPARTMENT_ID,
              SALARY,
              DATE_COL
       FROM EMPLOYEES, (SELECT SYSDATE() AS DATE_COL FROM DUAL) AS A1;

Join

Tipe join Oracle didukung oleh Cloud SQL untuk MySQL, kecuali untuk FULL JOIN. Gabungan Cloud SQL untuk MySQL mendukung penggunaan sintaksis alternatif, seperti klausa USING, klausa WHERE, bukan klausa ON, dan SUBQUERY dalam JOIN.

Tabel berikut menunjukkan JOIN contoh konversi.

Tipe `JOIN` Oracle	Dukungan Cloud SQL untuk MySQL	Sintaksis `JOIN` Cloud SQL untuk MySQL
`INNER JOIN`	Ya	`SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;`
`CROSS JOIN`	Ya	`SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E CROSS JOIN DEPARTMENTS D`
`FULL JOIN`	Tidak	Sebaiknya gunakan `UNION` dengan `LEFT` dan `RIGHT JOINS:` `SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E LEFT JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID UNION SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E RIGHT JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;`
`LEFT JOIN [ OUTER ]`	Ya	`SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E LEFT JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;`
`RIGHT JOIN [ OUTER ]`	Ya	`SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E RIGHT JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;`
`SUBQUERY`	Ya	`SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E JOIN (SELECT * FROM DEPARTMENTS)D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;`

Meskipun Cloud SQL untuk MySQL mendukung fungsi UNION dan UNION ALL, tetapi tidak mendukung fungsi INTERSECT dan MINUS Oracle:

UNION melampirkan kumpulan hasil dari dua pernyataan SELECT setelah menghapus data duplikat.
UNION ALL melampirkan kumpulan hasil dari dua pernyataan SELECT tanpa menghapus data duplikat.
INTERSECT menampilkan persimpangan dua pernyataan SELECT, hanya jika kumpulan data ada di kumpulan hasil dari kedua kueri.
MINUS membandingkan dua atau beberapa pernyataan SELECT, yang hanya menampilkan baris yang berbeda dari kueri pertama yang tidak ditampilkan oleh kueri kedua.

Tabel berikut menunjukkan beberapa contoh konversi Oracle ke Cloud SQL untuk MySQL.

Fungsi Oracle	Implementasi Oracle	Dukungan Cloud SQL untuk MySQL	Setara dengan Cloud SQL untuk MySQL
`UNION`	`SELECT COL1 FROM TBL1` `UNION` `SELECT COL1 FROM TBL2`	Ya	`SELECT COL1 FROM TBL1` `UNION` `SELECT COL1 FROM TBL2`
`UNION ALL`	`SELECT COL1 FROM TBL1` `UNION ALL` `SELECT COL1 FROM TBL2`	Ya	`SELECT COL1 FROM TBL1` `UNION ALL` `SELECT COL1 FROM TBL2`
`INTERSECT`	`SELECT COL1 FROM TBL1` `INTERSECT` `SELECT COL1 FROM TBL2`	Tidak	`SELECT COL1 FROM TBL1` `WHERE COL1 IN` `(SELECT COL1 FROM TBL2)`
`MINUS`	`SELECT COL1 FROM TBL1` `MINUS` `SELECT COL1 FROM TBL2`	Tidak	`SELECT A.COL1 FROM TBL1 A LEFT JOIN TBL2 B ON USING(COL1) WHERE B.COL1 IS NULL`

Fungsi skalar dan grup

Cloud SQL untuk MySQL menyediakan daftar lengkap fungsi skalar (baris tunggal) dan agregasi. Beberapa fungsi Cloud SQL untuk MySQL mirip dengan fungsi Oracle-nya (berdasarkan nama dan fungsionalitas, atau dengan nama yang berbeda tetapi dengan fungsionalitas yang sama). Meskipun beberapa fungsi Cloud SQL untuk MySQL dapat memiliki nama yang identik dengan fungsi Oracle lainnya, fungsi tersebut juga dapat menampilkan fungsionalitas yang berbeda.

Tabel berikut menjelaskan di mana fungsi karakter Oracle dan Cloud SQL untuk MySQL setara berdasarkan nama dan fungsi, dan tempat konversi direkomendasikan.

Fungsi Oracle	Implementasi Oracle	Setara dengan Cloud SQL untuk MySQL	Fungsi Cloud SQL untuk MySQL	Implementasi Cloud SQL untuk MySQL
`CONCAT`	Menampilkan string pertama yang disambungkan dengan string kedua: `CONCAT('A', 1) = A1`	Ya	`CONCAT`	`CONCAT('A', 1) = A1`
`CONCAT USING PIPE`	`FNAME \|' '\| LNAME`	Tidak	`CONCAT`	`CONCAT(FNAME, ' ', LNAME)`
`LOWER` atau `UPPER`	Menampilkan string, dengan semua huruf ditulis dalam huruf kecil atau huruf besar: `LOWER('SQL') = sql`	Ya	`LOWER` atau `UPPER`	`LOWER('SQL') = sql`
`LPAD/RPAD`	Menampilkan `expression1`, dengan padding kiri atau kanan hingga panjang karakter `n` dengan urutan karakter di `expression2`: `LPAD('A',3,'') = *A`	Ya	`LPAD` atau `RPAD`	`LPAD('A',3,'') = *A`
`SUBSTR`	Menampilkan sebagian string, mulai dari posisi `x` (dalam kasus ini 3), dengan panjang `y`. Posisi pertama dalam string adalah 1. `SUBSTR('MySQL', 3, 3) = SQL`	Ya	`SUBSTR`	`SUBSTR('MySQL', 3, 3) = SQL`
`INSTR`	Menampilkan posisi (indeks) string dari string tertentu: `INSTR('MySQL', 'y') = 2`	Ya	`INSTR`	`INSTR('MySQL', 'y') = 2`
`REPLACE`	Menampilkan string dengan setiap kemunculan string penelusuran yang diganti dengan string pengganti: `REPLACE('ORADB', 'ORA', 'MySQL') = MySQLDB`	Ya	`REPLACE`	`REPLACE('ORADB', 'ORA', 'MySQL') = MySQLDB`
`TRIM`	Memangkas karakter awal atau akhir (atau keduanya) dari string: `TRIM(both '-' FROM '-MySQL-') = MySQL TRIM(' MySQL ') = MySQL`	Ya	`TRIM`	`TRIM(both '-' FROM '-MySQL-') = MySQL TRIM(' MySQL ') = MySQL`
`LTRIM/RTRIM`	Menghapus semua karakter yang muncul dalam penelusuran dari sisi kiri atau kanan string: `LTRIM(' MySQL', ' ') = MySQL`	Sebagian	`LTRIM or RTRIM`	Fungsi `LTRIM` dan `RTRIM` Oracle menggunakan parameter kedua yang menentukan karakter awal atau akhir yang akan dihapus dari string. Fungsi Cloud SQL untuk MySQL hanya menghapus spasi kosong di awal dan di akhir dari string yang ditentukan: `LTRIM(' MySQL') = MySQL`
`ASCII`	Mengambil satu karakter dan menampilkan kode ASCII numeriknya: `ASCII('A') = 65`	Ya	`ASCII`	`ASCII('A') = 65`
`CHR`	Menampilkan nilai kode ASCII, yang merupakan nilai numerik dari 0 hingga 225, menjadi karakter: `CHR(65) = A`	Memerlukan nama fungsi yang berbeda	`CHAR`	Cloud SQL untuk MySQL menggunakan fungsi `CHAR` untuk fungsi yang sama, sehingga Anda perlu mengubah nama fungsi: `CHAR(65) = A`
`LENGTH`	Menampilkan panjang string yang diberikan: `LENGTH('MySQL') = 5`	Ya	`LENGTH`	`LENGTH('MySQL') = 5`
`REGEXP_REPLACE`	Menelusuri string untuk pola ekspresi reguler: `REGEXP_REPLACE('John', '[hn].', 'e') = Joe`	Tidak	T/A	Didukung pada MySQL versi 8. Sebagai solusinya, gunakan fungsi `REPLACE` jika memungkinkan atau pindahkan logika ke lapisan aplikasi.
`REGEXP_SUBSTR`	Memperluas fungsi `SUBSTR` dengan menelusuri string untuk pola ekspresi reguler: `REGEXP_SUBSTR('https://console.cloud.google.com/sql/instances','https://([[:alnum:]]+\.?){3,4}/?') = https://console.cloud.google.com/`	Tidak	T/A	Didukung pada MySQL versi 8. Sebagai solusinya, gunakan fungsi `SUBSTR` jika memungkinkan atau pindahkan logika ke lapisan aplikasi
`REGEXP_COUNT`	Menampilkan frekuensi terjadinya pola di string sumber	Tidak	T/A	Tidak ada fungsi setara yang tersedia untuk Cloud SQL untuk MySQL. Pindahkan logika ini ke lapisan aplikasi.
`REGEXP_INSTR`	Menelusuri posisi string (indeks) untuk pola ekspresi reguler	Tidak	T/A	Didukung pada MySQL versi 8. Jika menggunakan versi yang lebih lama, pindahkan logika ini ke lapisan aplikasi.
`REVERSE`	Menampilkan string terbalik untuk string tertentu: `REVERSE('MySQL') = LQSyM`	Ya	`REVERSE`	`REVERSE('MySQL') = LQSyM`

Tabel berikut menjelaskan posisi fungsi numerik Oracle dan Cloud SQL untuk MySQL yang setara berdasarkan nama dan fungsi, serta tempat konversi direkomendasikan.

Fungsi Oracle	Implementasi Oracle	Setara dengan Cloud SQL untuk MySQL	Fungsi Cloud SQL untuk MySQL	Implementasi Cloud SQL untuk MySQL
`ABS`	Menampilkan nilai absolut dari angka yang ditentukan: `ABS(-4.6) = 4.6`	Ya	`ABS`	`ABS(-4.6) = 4.6`
`CEIL`	Menampilkan bilangan bulat terkecil yang lebih besar dari atau sama dengan bilangan yang diberikan: `CEIL(21.4) = 22`	Ya	`CEIL`	`CEIL(21.4) = 22`
`FLOOR`	Menampilkan bilangan bulat terbesar yang sama dengan atau kurang dari bilangan yang diberikan: `FLOOR(-23.7) = -24`	Ya	`FLOOR`	`FLOOR(-23.7) = -24`
`MOD`	Menampilkan sisa `m` yang dibagi `n`: `MOD(10, 3) = 1`	Ya	`MOD`	`MOD(10, 3) = 1`
`ROUND`	Menampilkan `n` yang dibulatkan ke tempat bilangan bulat di sebelah kanan titik desimal: `ROUND(1.39, 1) = 1.4`	Ya	`ROUND`	`ROUND(1.39, 1) = 1.4`
`TRUNC`(angka)	Menampilkan `n1` yang dipotong menjadi `n2` titik desimal. Parameter kedua bersifat opsional. `TRUNC(99.999) = 99 TRUNC(99.999, 0) = 99`	Memerlukan nama fungsi yang berbeda	`TRUNCATE`(angka)	Fungsi Cloud SQL untuk MySQL memiliki nama yang berbeda dan parameter kedua wajib diisi. `TRUNCATE(99.999, 0) = 99`

Tabel berikut menjelaskan di mana fungsi datetime Oracle dan Cloud SQL untuk MySQL setara berdasarkan nama dan fungsionalitasnya, dan tempat konversi direkomendasikan.

Fungsi Oracle	Implementasi Oracle	Setara dengan Cloud SQL untuk MySQL	Fungsi Cloud SQL untuk MySQL	Implementasi Cloud SQL untuk MySQL
`SYSDATE`	Menampilkan tanggal dan waktu saat ini yang ditetapkan untuk sistem operasi tempat server database berada: `SELECT SYSDATE FROM DUAL; = 31-JUL-2019`	Ya	`SYSDATE()`	`SYSDATE()` Cloud SQL untuk MySQL harus menyertakan tanda kurung dan secara default menampilkan format `datetime` yang berbeda dari fungsi `SYSDATE` Oracle: `SELECT SYSDATE() FROM DUAL; = 2019-01-31 10:01:01.0` Anda dapat mengubah format `datetime` di tingkat sesi
`SYSTIMESTAMP`	Menampilkan tanggal sistem, termasuk detik pecahan dan zona waktu: `SELECT SYSTIMESTAMP FROM DUAL = 01-JAN-19 07.37.11.622187000 AM +00:00`	Memerlukan nama fungsi yang berbeda	`CURRENT_ TIMESTAMP`	Fungsi Cloud SQL untuk MySQL menampilkan format `datetime` yang berbeda secara default. Untuk memformat ulang output, gunakan fungsi `DATE_FORMAT()`. `SELECT CURRENT_TIMESTAMP FROM DUAL; = 2019-01-31 06:55:07`
`LOCAL_ TIMESTAMP`	Menampilkan tanggal dan waktu saat ini sebagai jenis `TIMESTAMP`: `SELECT LOCALTIMESTAMP FROM DUAL = 01-JAN-19 10.01.10.123456 PM`	Menampilkan format `datetime` yang berbeda	`LOCAL_ TIMESTAMP`	Fungsi Cloud SQL untuk MySQL menampilkan format `datetime` yang berbeda dari format default untuk Oracle. Untuk memformat ulang output, gunakan fungsi `DATE_FORMAT()`. `SELECT LOCAL_TIMESTAMP FROM DUAL = 2019-01-01 10:01:01.0`
`CURRENT_DATE`	Menampilkan tanggal saat ini: `SELECT CURRENT_DATE FROM DUAL = 31-JAN-19`	Menampilkan format `datetime` yang berbeda	`CURRENT_ DATE`	Fungsi Cloud SQL untuk MySQL menampilkan format `datetime` yang berbeda. Untuk memformat ulang output, gunakan fungsi `DATE_FORMAT()`. `SELECT CURRENT_DATE FROM DUAL = 2019-01-31`
`CURRENT_ TIMESTAMP`	Menampilkan tanggal dan waktu saat ini: `SELECT CURRENT_TIMESTAMP FROM DUAL = 31-JAN-19 06.54.35.543146 AM +00:00`	Menampilkan format `datetime` yang berbeda	`CURRENT_ TIMESTAMP`	Fungsi Cloud SQL untuk MySQL menampilkan format `datetime` yang berbeda. Untuk memformat ulang output, gunakan fungsi `DATE_FORMAT()`. `SELECT CURRENT_TIMESTAMP FROM DUAL = 2019-01-31 06:55:07`
`ADD_MONTHS`	Menampilkan tanggal plus bulan bilangan bulat: `ADD_MONTHS(SYSDATE, 1) = 31-JAN-19`	Memerlukan nama fungsi yang berbeda	`ADDDATE`	Fungsi Cloud SQL untuk MySQL menampilkan format `datetime` yang berbeda. Untuk memformat ulang output, gunakan fungsi `DATE_FORMAT()`. `ADDDATE(SYSDATE(), 1) = 2019-08-01 06:42:49.0`
`EXTRACT` (bagian tanggal)	Menampilkan nilai kolom `datetime` berdasarkan ekspresi interval: `EXTRACT(YEAR FROM DATE '2019-01-31') = 2019`	Ya	`EXTRACT` (bagian tanggal)	`EXTRACT(YEAR FROM DATE '2019-01-31') = 2019`
`LAST_DAY`	Menampilkan hari terakhir dalam sebulan untuk tanggal yang ditentukan: `LAST_DAY('01-JAN-2019') = 31-JAN-19`	Sebagian	`LAST_DAY`	Fungsi Cloud SQL untuk MySQL menampilkan format `datetime` yang berbeda dari format default untuk Oracle. Untuk memformat ulang output, gunakan fungsi `DATE_FORMAT()`. `LAST_DAY('2019-01-01') = 2019-01-31`
`MONTH_ BETWEEN`	Menampilkan jumlah bulan antara tanggal yang ditentukan `date1` dan `date2`: `MONTHS_BETWEEN( SYSDATE, SYSDATE-60) = 1.96`	Sebagian	`PERIOD_DIFF`	Fungsi `PERIOD_DIFF` Cloud SQL untuk MySQL menampilkan selisih bulan sebagai bilangan bulat antara dua periode (diformat sebagai `YYMM` atau `YYYYMM`): `PERIOD_DIFF( '201903', '201901') = 2`
`TO_CHAR (Datetime)`	Mengonversi jenis angka, `datetime`, atau stempel waktu menjadi jenis string `TO_CHAR( SYSDATE,'DD-MM-YYYY HH24:MI:SS') = 01-01-2019 10:01:01`	Memerlukan nama fungsi yang berbeda	`DATE_FORMAT`	Fungsi `DATE_FORMAT` Cloud SQL untuk MySQL memformat nilai tanggal sesuai dengan string format: `DATE_FORMAT( SYSDATE(),'%d-%m-%Y %H:%i:%s') 01-01-2019 10:01:01`

Tabel berikut menjelaskan posisi fungsi encoding dan decoding Oracle dan Cloud SQL untuk MySQL setara berdasarkan nama dan fungsi, serta lokasi yang direkomendasikan untuk konversi.

Fungsi Oracle	Implementasi Oracle	Setara dengan Cloud SQL untuk MySQL	Fungsi Cloud SQL untuk MySQL	Implementasi Cloud SQL untuk MySQL
`DECODE`	Membandingkan ekspresi dengan setiap nilai penelusuran satu per satu menggunakan fungsi pernyataan `IF-THEN-ELSE`	Tidak	`CASE`	Gunakan pernyataan `CASE` Cloud SQL untuk MySQL untuk fungsi serupa
`DUMP`	Menampilkan nilai `VARCHAR2` yang berisi kode jenis data, panjang dalam byte, dan representasi internal ekspresi	Tidak	T/A	Tidak didukung
`ORA_HASH`	Menghitung nilai hash untuk ekspresi tertentu	Tidak	`MD5 or SHA`	Menggunakan fungsi `MD5` untuk checksum 128-bit atau fungsi `SHA` untuk checksum 160-bit

Tabel berikut menjelaskan di mana fungsi konversi Oracle dan Cloud SQL untuk MySQL setara berdasarkan nama dan fungsionalitasnya, dan tempat konversi direkomendasikan.

Fungsi Oracle	Implementasi Oracle	Setara dengan Cloud SQL untuk MySQL	Fungsi Cloud SQL untuk MySQL	Implementasi Cloud SQL untuk MySQL
`CAST`	Mengonversi satu jenis data bawaan atau nilai berjenis koleksi menjadi jenis data bawaan atau nilai berjenis koleksi lainnya: `CAST('1' as int) + 1 = 2`	Sebagian	`CAST`	Sesuaikan bergantung pada apakah konversi eksplisit atau implisit diperlukan: `CAST('1' AS SIGNED) + 1 = 2`
`CONVERT`	Mengonversi string karakter dari himpunan satu karakter ke karakter lain: `CONVERT ( 'Ä Ê Í Õ Ø A B C D E ', 'US7ASCII', 'WE8ISO8859P1') = ?? ?? ?? A B C`	Sebagian	`CONVERT`	Fungsi `CONVERT` Cloud SQL untuk MySQL memerlukan beberapa penyesuaian pada sintaksis dan parameternya: `CONVERT( 'Ä Ê Í A B C ' USING utf8) = Ä Ê Í A B C`
`TO_CHAR` (string/numerik)	Fungsi ini mengonversi angka atau tanggal menjadi string: `TO_CHAR(22.73,'$99.9') = $22.7`	Tidak	`FORMAT`	Fungsi `FORMAT` Cloud SQL untuk MySQL mengonversi angka ke format seperti `#,###,###.##`, membulatkannya ke titik dan angka desimal, lalu menampilkan hasilnya sebagai string: `CONCAT('$', FORMAT(22.73, 1)) = $22.7`
`TO_DATE`	Fungsi `TO_DATE` Oracle mengonversi string menjadi tanggal berdasarkan format `datetimecode`: `TO_DATE( '2019/01/01', 'yyyy-mm-dd') = 01-JAN-2019`	Memerlukan nama fungsi yang berbeda	`STR_TO_DATE`	Fungsi `STR_TO_DATE` Cloud SQL untuk MySQL mengambil string dan menampilkan tanggal berdasarkan format `datetime`: `STR_TO_DATE( '2019/01/01', '%Y/%m/%d') = 2019-01-01`
`TO_NUMBER`	Mengonversi ekspresi ke nilai jenis data `NUMBER`: `TO_NUMBER('01234') = 1234`	Memerlukan nama fungsi yang berbeda	`CAST`	Gunakan fungsi `CAST` Cloud SQL untuk MySQL untuk menampilkan hasil yang sama dengan fungsi `TO_NUMBER` Oracle: `CAST('01234' as SIGNED) = 1234`

Tabel berikut menjelaskan posisi fungsi SELECT kondisional Oracle dan Cloud SQL untuk MySQL setara berdasarkan nama dan fungsi, serta tempat konversi direkomendasikan.

Fungsi Oracle	Implementasi Oracle	Setara dengan Cloud SQL untuk MySQL	Fungsi Cloud SQL untuk MySQL	Implementasi Cloud SQL untuk MySQL
`CASE`	Pernyataan `CASE` memilih dari urutan kondisi dan menjalankan pernyataan yang sesuai dengan sintaksis berikut: `CASE WHEN condition THEN result [WHEN ...] [ELSE result] END`	Ya	`CASE`	Selain fungsi `CASE`, Cloud SQL untuk MySQL mendukung penggunaan penanganan kondisional `IF/ELSE` di dalam pernyataan `SELECT`: `CASE WHEN condition THEN result [WHEN ...] [ELSE result] END`

Tabel berikut menjelaskan lokasi fungsi null Oracle dan Cloud SQL untuk MySQL setara berdasarkan nama dan fungsi, serta tempat konversi direkomendasikan.

Fungsi Oracle	Implementasi Oracle	Setara dengan Cloud SQL untuk MySQL	Fungsi Cloud SQL untuk MySQL	Implementasi Cloud SQL untuk MySQL
`COALESCE`	Menampilkan ekspresi non-null pertama dalam daftar ekspresi: `COALESCE( null, '1', 'a') = a`	Ya	`COALESCE`	`COALESCE( null, '1', 'a') = 1`
`NULLIF`	Melakukan perbandingan antara `expression1` dan `expression2`. Jika keduanya sama, fungsi akan menampilkan `null`. Jika tidak sama, fungsi akan menampilkan `expression1`: `NULLIF('1', '2') = a`	Ya	`NULLIF`	`NULLIF('1', '2') = a`
`NVL`	Mengganti nilai `null` dengan string dalam hasil kueri: `NVL(null, 'a') = a`	Tidak	`IFNULL`	`IFNULL(null, 'a') = a`
`NVL2`	Menentukan nilai yang ditampilkan oleh kueri berdasarkan apakah suatu ekspresi bernilai null atau bukan null	Tidak	`CASE`	Pernyataan `CASE` memilih dari urutan kondisi dan menjalankan pernyataan yang sesuai: `CASE WHEN condition THEN result [WHEN ...] [ELSE result] END`

Tabel berikut menjelaskan status lingkungan dan fungsi ID Oracle dan Cloud SQL untuk MySQL yang setara berdasarkan nama dan fungsi, serta tempat konversi direkomendasikan.

Fungsi Oracle	Implementasi Oracle	Setara dengan Cloud SQL untuk MySQL	Fungsi Cloud SQL untuk MySQL	Implementasi Cloud SQL untuk MySQL
`SYS_GUID`	Menghasilkan dan menampilkan ID unik global (nilai `RAW`) yang terdiri dari 16 byte: `SELECT SYS_GUID() FROM DUAL = 8EFA4A31468B4C6DE05011AC0200009E`	Tidak	`REPLACE` dan `UUID`	Sebagai solusinya, gunakan fungsi `REPLACE` dan `UUID` untuk menyimulasikan fungsi `SYS_GUID`: `REPLACE( UUID(), '-', '')`
`UID`	Menampilkan bilangan bulat yang mengidentifikasi pengguna sesi secara unik (pengguna yang login): `SELECT UID FROM DUAL = 43`	Tidak	T/A	T/A
`USER`	Menampilkan nama pengguna yang terhubung ke sesi saat ini: `SELECT USER FROM DUAL = username`	Ya	`USER + INSTR + SUBSTR`	Fungsi `USER` Cloud SQL untuk MySQL menampilkan nama pengguna dan nama host (`root@IP_ADDRESS`) untuk koneksi tersebut. Untuk mengambil nama pengguna saja, gunakan fungsi pendukung tambahan: `SELECT SUBSTR(USER(), 1, INSTR(USER(), '@') -1) FROM DUAL = root`
`USERENV`	Menampilkan informasi tentang sesi Oracle saat ini, seperti bahasa sesi: `SELECT USERENV('LANGUAGE') FROM DUAL = ENGLISH_AMERICA. AL32UTF8`	Tidak	`SHOW SESSION VARIABLES`	Pernyataan `SHOW SESSION VARIABLES` Cloud SQL untuk MySQL menampilkan setelan untuk sesi saat ini: `SHOW SESSION VARIABLES LIKE '%collation%'; = utf8_general_ci`
`ROWID`	Oracle menetapkan `ROWID` unik pada setiap baris tabel untuk mengidentifikasi baris dalam tabel. `ROWID` adalah alamat baris yang berisi nomor objek data, blok data baris, posisi baris, dan file data.	Sebagian	T/A	`ROW_NUMBER()` tersedia mulai di MySQL 8.0. Jika Anda menggunakan versi sebelumnya, emulasikan fungsi yang sama menggunakan variabel sesi `@row_number`.
`ROWNUM`	Menampilkan angka yang mewakili urutan baris yang ditampilkan oleh tabel Oracle	Sebagian	T/A	`ROW_NUMBER()` tersedia mulai di MySQL 8.0. Jika Anda menggunakan versi sebelumnya, emulasikan fungsi yang sama menggunakan variabel sesi `@row_number`.

Tabel berikut menjelaskan posisi fungsi agregat (grup) Oracle dan Cloud SQL untuk MySQL yang setara berdasarkan nama dan fungsi, serta tempat konversi direkomendasikan.

Fungsi Oracle	Implementasi Oracle	Setara dengan Cloud SQL untuk MySQL	Fungsi Cloud SQL untuk MySQL	Implementasi Cloud SQL untuk MySQL
`AVG`	Menampilkan nilai rata-rata kolom atau ekspresi	Ya	`AVG`	Setara dengan Oracle
`COUNT`	Menampilkan jumlah baris yang dikembalikan oleh kueri	Ya	`COUNT`	Setara dengan Oracle
`COUNT (DISTINCT)`	Menampilkan jumlah nilai unik dalam kolom atau ekspresi	Ya	`COUNT (DISTINCT)`	Setara dengan Oracle
`MAX`	Menampilkan nilai maksimum kolom atau ekspresi	Ya	MAX	Setara dengan Oracle
`MIN`	Menampilkan nilai minimum kolom atau ekspresi	Ya	`MIN`	Setara dengan Oracle
`SUM`	Menampilkan jumlah nilai dari kolom atau ekspresi	Ya	`SUM`	Setara dengan Oracle
`LISTAGG`	Mengurutkan data dalam setiap grup yang ditentukan dalam klausa `ORDER BY` dan menggabungkan nilai kolom pengukuran: `SELECT LISTAGG( DEPARTMENT_NAME, ', ') WITHIN GROUP (ORDER BY DEPARTMENT_NAME) DEPT FROM DEPARTMENTS; -- Single line results = Accounting, Administration, Benefits, Construction`	Memerlukan sintaksis dan nama fungsi yang berbeda	`GROUP_ CONCAT`	Gunakan fungsi `GROUP_CONCAT` Cloud SQL untuk MySQL untuk menampilkan hasil yang setara: `SELECT GROUP_CONCAT( DEPARTMENT_NAME ORDER BY DEPARTMENT_NAME SEPARATOR ', ') DEPT FROM DEPARTMENTS; -- Single line results = Accounting, Administration, Benefits, Construction`

Tabel berikut menjelaskan di mana fungsi FETCH Oracle dan Cloud SQL untuk MySQL setara berdasarkan nama dan fungsi.

Fungsi Oracle	Implementasi Oracle	Setara dengan Cloud SQL untuk MySQL	Fungsi Cloud SQL untuk MySQL	Implementasi Cloud SQL untuk MySQL
`FETCH`	Mengambil jumlah baris yang ditentukan dari kumpulan hasil kueri multi-baris: `SELECT * FROM EMPLOYEES FETCH FIRST 10 ROWS ONLY;`	Ya	`LIMIT`	Gunakan klausa `LIMIT` MySQL untuk mengambil baris dari kueri: `SELECT * FROM EMPLOYEES LIMIT 10;`

Filter, operator, dan sub kueri dasar

Pemfilteran dasar, fungsi operator, dan subkueri relatif mudah untuk dikonversi, dengan upaya nominal yang diperlukan. Sebagian besar upaya tersebut berkisar pada konversi format tanggal karena Oracle dan Cloud SQL untuk MySQL menggunakan format tanggal default yang berbeda:

Fungsi SYSDATE Oracle menampilkan format ini secara default: 01-AUG-19.
Fungsi SYSDATE() Cloud SQL untuk MySQL menampilkan format ini secara default: 2019-08-01 12:04:05.

Untuk menyetel format tanggal dan waktu, gunakan fungsi DATE_FORMAT atau STR_TO_DATE pada MySQL.

Tabel berikut menjelaskan posisi pemfilteran dasar, operator, dan fungsi subkueri Oracle dan Cloud SQL untuk MySQL yang setara berdasarkan nama dan fungsi, serta tempat konversi direkomendasikan.

Fungsi Oracle	Implementasi Oracle	Setara dengan Cloud SQL untuk MySQL	Fungsi Cloud SQL untuk MySQL
`EXISTS/ NOT EXISTS`	Ya	`EXISTS/ NOT EXISTS`	`SELECT * FROM DEPARTMENTS D WHERE EXISTS (SELECT 1 FROM EMPLOYEES E WHERE E.DEPARTMENT_ID = D.DEPARTMENT_ID);`
`IN/NOT IN`	Ya	`IN/NOT IN`	`SELECT * FROM DEPARTMENTS D WHERE DEPARTMENT_ID IN (SELECT DEPARTMENT_ID FROM EMPLOYEES E); -- OR SELECT * FROM EMPLOYEES WHERE (EMPLOYEE_ID, DEPARTMENT_ID) IN((100, 90));`
`LIKE/NOT LIKE`	Ya	`LIKE/NOT LIKE`	`SELECT * FROM EMPLOYEES WHERE FIRST_NAME LIKE '_e_n%';`
`BETWEEN/ NOT BETWEEN`	Ya	`BETWEEN/ NOT BETWEEN`	`SELECT * FROM EMPLOYEES WHERE EXTRACT(YEAR FROM HIRE_DATE) NOT BETWEEN 2001 and 2004;`
`AND/OR`	Ya	`AND/OR`	`SELECT * FROM EMPLOYEES WHERE DEPARTMENT_ID IN(100, 101) AND (SALARY >= 1000 OR HIRE_DATE <= '2006-02-05');`
`SubQuery`	Ya	`SubQuery`	Cloud SQL untuk MySQL mendukung subkueri dalam klausa `SELECT`, pada klausa `JOIN`, dan untuk memfilter dalam klausa `WHERE/AND`: `-- SELECT Subquery SELECT D.DEPARTMENT_NAME, (SELECT AVG(SALARY) AS AVG_SAL FROM EMPLOYEES E WHERE E.DEPARTMENT_ID = D.DEPARTMENT_ID) AVG_SAL FROM DEPARTMENTS D; -- JOIN Subquery SELECT FIRST_NAME, LAST_NAME, SALARY FROM EMPLOYEES E JOIN (SELECT * FROM DEPARTMENTS WHERE LOCATION_ID = 2700) D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID; -- Filtering Subquery SELECT FIRST_NAME, LAST_NAME, SALARY FROM EMPLOYEES WHERE SALARY < (SELECT AVG(SALARY) FROM EMPLOYEES);`
Operator	Ya	Operator	Cloud SQL untuk MySQL mendukung semua operator dasar: `> \| >= \| < \| <= \| = \| <> \| !=`

Praktik terbaik untuk kueri Cloud SQL untuk MySQL

Untuk mempertahankan tingkat performa yang sebanding antara Cloud SQL untuk MySQL dan Oracle, Anda mungkin perlu mengoptimalkan kueri Anda. Pengoptimalan ini termasuk mengubah struktur indeks dan menyesuaikan skema database. Bagian ini berisi beberapa panduan untuk membantu Anda mencapai performa kueri yang sebanding di Cloud SQL untuk MySQL.

Membuat indeks dengan cluster

Saat menggunakan mesin penyimpanan InnoDB, praktik terbaiknya adalah menentukan tabel dengan kunci utama, karena kunci ini membuat indeks yang dikelompokkan pada tabel tersebut. Selain meningkatkan performa kueri, pendekatan ini juga memungkinkan Anda membuat indeks sekunder tambahan. Namun, Anda sebaiknya menghindari membuat terlalu banyak indeks. Memiliki indeks yang berlebihan tidak akan meningkatkan performa dan dapat memperlambat eksekusi DML. Praktik terbaik ini mengarah pada praktik terbaik kedua: pantau secara rutin indeks redundan, dan jika ada indeks redundan, hapus indeks tersebut dari database.

Gunakan kueri berikut untuk mengidentifikasi tabel tanpa kunci utama sehingga Anda dapat membuat kunci utama untuk tabel tersebut:

mysql> SELECT t.table_schema, t.table_name
       FROM information_schema.tables t LEFT JOIN
       information_schema.statistics s
       ON t.table_schema=s.table_schema AND t.table_name=s.table_name
       AND s.non_unique=0
       WHERE s.table_name IS NULL
       AND t.table_schema NOT IN('sys', 'information_schema', 'mysql',
       'performance_schema')
       AND t.`TABLE_TYPE` <> 'VIEW';

Gunakan kueri berikut untuk menemukan tabel yang tidak memiliki indeks sehingga Anda dapat membuat indeks untuk tabel tersebut:

mysql> SELECT t.table_schema, t.table_name FROM INFORMATION_SCHEMA.tables t
       WHERE table_name NOT IN
             (SELECT  table_name FROM (
                      SELECT  table_name, index_name
                      FROM information_schema.statistics
                  GROUP BY  table_name, index_name) tab_ind_cols
           GROUP BY table_name)
AND table_schema NOT IN('sys', 'information_schema', 'mysql', 'performance_schema')
AND TABLE_TYPE <> 'VIEW';

Gunakan kueri berikut untuk memeriksa indeks redundan sehingga Anda dapat menghapus redundansi:

mysql> SELECT * FROM sys.schema_redundant_indexes;

Menyesuaikan parameter kueri

Untuk menyesuaikan performa kueri, Anda mungkin perlu menyesuaikan parameter sesi. Cloud SQL untuk MySQL memiliki sekumpulan flag yang dapat Anda ubah untuk tujuan ini, termasuk flag berikut:

Parameter terkait InnoDB
Parameter SORT
Parameter JOIN
Parameter penanganan cache

Memantau kueri

Kueri yang berjalan lambat dapat menyebabkan sistem berhenti merespons atau menyebabkan bottleneck lain, sehingga penting untuk memantau kueri secara rutin.

Ada beberapa cara untuk mendiagnosis pernyataan SQL yang berjalan lambat:

Gunakan dasbor Cloud SQL untuk MySQL untuk insight real-time dan historis tentang kueri yang berjalan lambat.
Menggunakan Cloud Monitoring untuk memantau log kueri lambat Cloud SQL untuk MySQL.
Gunakan tampilan statement_analysis Cloud SQL untuk MySQL untuk melihat statistik runtime tentang pernyataan SQL:
```
mysql> SELECT * FROM sys.statement_analysis;
```

Menganalisis kueri Cloud SQL untuk MySQL

Pengoptimal kueri di Cloud SQL untuk MySQL menghasilkan rencana eksekusi untuk pernyataan SELECT, INSERT, UPDATE, dan DELETE. Paket ini berguna saat Anda menyesuaikan kueri yang berjalan lambat. Ada beberapa pertimbangan yang harus diperhatikan:

Rencana eksekusi bukanlah objek database yang perlu dimigrasikan, melainkan alat untuk menganalisis perbedaan performa antara Oracle dan Cloud SQL untuk MySQL yang menjalankan pernyataan yang sama pada set data yang identik.
Cloud SQL untuk MySQL tidak mendukung sintaksis, fungsi, atau output rencana eksekusi yang sama dengan Oracle.

Berikut adalah contoh rencana untuk menggambarkan perbedaan antara paket eksekusi Oracle dan paket eksekusi Cloud SQL untuk MySQL:

SQL> EXPLAIN PLAN FOR
     SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 105;

SQL> SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY (FORMAT=>'ALL +OUTLINE'));

Plan hash value: 1833546154

---------------------------------------------------------------------------------------------
| Id  | Operation                   | Name          | Rows  | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT            |               |     1 |    69 |     1   (0)| 00:00:01 |
|   1 |  TABLE ACCESS BY INDEX ROWID| EMPLOYEES     |     1 |    69 |     1   (0)| 00:00:01 |
|*  2 |   INDEX UNIQUE SCAN         | EMP_EMP_ID_PK |     1 |       |     0   (0)| 00:00:01 |
---------------------------------------------------------------------------------------------

mysql> EXPLAIN SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 105;

+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
| id | select_type | table     | partitions | type  | possible_keys | key     | key_len | ref   | rows | filtered | Extra |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
|  1 | SIMPLE      | EMPLOYEES | NULL       | const | PRIMARY       | PRIMARY | 3       | const |    1 |   100.00 | NULL  |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+

Mengoptimalkan prosedur dan pemicu yang tersimpan

Berbeda dengan Oracle, prosedur dan fungsi yang tersimpan Cloud SQL untuk MySQL diuraikan pada setiap eksekusi. Alat yang berguna untuk mengukur prosedur tersimpan dan performa fungsi adalah utilitas BENCHMARK() MySQL. Alat ini memerlukan dua parameter, jumlah iterasi dan ekspresi, serta memperkirakan runtime ekspresi yang diberikan (misalnya, prosedur, fungsi, dan pernyataan SELECT yang disimpan). Outputnya menunjukkan perkiraan total runtime untuk semua iterasi.

Berikut adalah contoh untuk mengilustrasikan utilitas BENCHMARK():

-- SELECT Expression Example

mysql> select benchmark(10000000, 'select sysdate()');
+-----------------------------------------+
| benchmark(10000000, 'select sysdate()') |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
1 row in set (0.12 sec)

-- Result: Run time of 0.12 sec for 1,0000,000 iterations

-- FUNCTION Example
mysql> select benchmark(1000000, func1());
+-----------------------------+
| benchmark(1000000, func1()) |
+-----------------------------+
|                           0 |
+-----------------------------+
1 row in set (2.54 sec)

-- Result: Run time of 2.54 sec for 1,000,000 iterations

Jika Anda melihat adanya regresi performa selama konversi, gunakan perintah EXPLAIN MySQL untuk mengidentifikasi kemungkinan faktor yang berkontribusi pada regresi tersebut. Salah satu solusi umum untuk performa yang lambat adalah dengan mengubah struktur indeks tabel untuk mengakomodasi pengoptimal MySQL. Praktik umum lainnya adalah mengoptimalkan kode PL/SQL yang dikonversi dengan mengurangi pengambilan data yang tidak perlu atau dengan menggunakan tabel sementara dalam kode MySQL prosedural.

Langkah selanjutnya

Pelajari akun pengguna MySQL lebih lanjut.
Pelajari arsitektur referensi, diagram, dan praktik terbaik tentang Google Cloud. Lihat Cloud Architecture Center kami.