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 |
SELECTFROMWHEREGROUP BYHAVINGORDER BY
|
Ya |
SELECTFROMWHEREGROUP BYHAVINGORDER BY
|
SELECT
untuk cetak output |
SELECT 1 FROM DUAL
|
Ya |
SELECT 1atau SELECT 1 FROM DUAL
|
| Alias kolom | SELECT COL1 AS C1
|
Ya |
SELECT COL1 AS C1atau 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:
UNIONmelampirkan kumpulan hasil dari dua pernyataanSELECTsetelah menghapus data duplikat.UNION ALLmelampirkan kumpulan hasil dari dua pernyataanSELECTtanpa menghapus data duplikat.INTERSECTmenampilkan persimpangan dua pernyataanSELECT, hanya jika kumpulan data ada di kumpulan hasil dari kedua kueri.MINUSmembandingkan dua atau beberapa pernyataanSELECT, 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 TBL1UNIONSELECT COL1 FROM TBL2
|
Ya | SELECT COL1 FROM TBL1UNIONSELECT COL1 FROM TBL2
|
UNION ALL |
SELECT COL1 FROM TBL1UNION ALLSELECT COL1 FROM TBL2
|
Ya | SELECT COL1 FROM TBL1UNION ALLSELECT COL1 FROM TBL2
|
INTERSECT |
SELECT COL1 FROM TBL1INTERSECTSELECT COL1 FROM TBL2
|
Tidak |
SELECT COL1 FROM TBL1WHERE COL1 IN(SELECT COL1 FROM TBL2)
|
MINUS |
SELECT COL1 FROM TBL1MINUSSELECT 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() |
SELECT SYSDATE()
FROM DUAL;
= 2019-01-31 10:01:01.0
Anda dapat mengubah format |
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 | 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
SYSDATEOracle 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_analysisCloud 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.