Memigrasikan pengguna Oracle ke Cloud SQL untuk MySQL: Kueri, prosedur tersimpan, fungsi, dan pemicu

Dokumen ini adalah bagian dari rangkaian yang menyajikan informasi dan panduan penting terkait perencanaan dan migrasi database Oracle® 11g/12c ke Cloud SQL untuk MySQL versi 5.7, instance generasi kedua. Seri ini mencakup bagian-bagian berikut:

• Memigrasikan pengguna Oracle ke Cloud SQL untuk MySQL: Terminologi dan fungsi
• Memigrasikan pengguna Oracle ke Cloud SQL untuk MySQL: Jenis data, pengguna, dan tabel
• Memigrasikan pengguna Oracle ke Cloud SQL untuk MySQL: Kueri, prosedur tersimpan, fungsi, dan pemicu (dokumen ini)
• Memigrasikan pengguna Oracle ke Cloud SQL untuk MySQL: Keamanan, operasi, pemantauan, dan logging

Kueri

Oracle dan Cloud SQL untuk MySQL mendukung standar ANSI SQL. Secara umum sangat mudah memigrasikan pernyataan SQL hanya dengan menggunakan elemen sintaksis dasar (misalnya, tidak menentukan fungsi skalar atau fitur diperluas Oracle lainnya). Bagian berikut membahas elemen kueri Oracle umum beserta ekuivalen Cloud SQL for MySQL yang sesuai.

Sintaksis SELECT dan FROM dasar

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

SELECT 1 FROM DUAL

SELECT 1
OR
SELECT 1 FROM DUAL

SELECT COL1 AS C1

SELECT COL1 AS C1
OR
SELECT COL1 C1

Anda dapat membaca detail selengkapnya tentang sintaksis SELECT MySQL.

• 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 meringkas beberapa kueri terpisah menjadi satu kueri yang disederhanakan.
  • Catatan konversi: Tampilan inline Oracle tidak memerlukan penggunaan alias, sedangkan MySQL memerlukan alias khusus untuk setiap tampilan inline.

Tabel berikut menampilkan contoh konversi dari Oracle ke MySQL, sebagai tampilan inline.

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

FIRST_NAME           DEPARTMENT_ID     SALARY DATE_COL
-------------------- ------------- ---------- ---------
Steven                          90      24000 30-JUL-19
Neena                           90      17000 30-JUL-19
Lex                             90      17000 30-JUL-19

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


ERROR 1248 (42000): Every derived table must have its own alias

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

+-------------+---------------+----------+---------------------+
| FIRST_NAME  | DEPARTMENT_ID | SALARY   | DATE_COL            |
+-------------+---------------+----------+---------------------+
| Steven      |            90 | 23996.00 | 2019-07-30 09:28:00 |
| Neena       |            90 | 22627.00 | 2019-07-30 09:28:00 |
| Lex         |            90 | 22627.00 | 2019-07-30 09:28:00 |

Pernyataan JOIN

Pernyataan JOIN Oracle didukung oleh pernyataan JOIN MySQL, kecuali untuk klausa FULL JOIN. Selain itu, pernyataan JOIN MySQL mendukung penggunaan sintaksis alternatif, seperti klausa USING, klausa WHERE sebagai ganti klausa ON, dan menggunakan SUBQUERY di pernyataan JOIN.

Tabel berikut menampilkan contoh konversi JOIN.

INNER JOIN

SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

CROSS JOIN

SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E CROSS JOIN DEPARTMENTS D

FULL JOIN

LEFT JOIN
[ OUTER ]

SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E LEFT JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

RIGHT JOIN
[ OUTER ]

SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E RIGHT JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

SUBQUERY

SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E JOIN (SELECT * FROM DEPARTMENTS)D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

UNION, UNION ALL, INTERSECT, dan MINUS

MySQL tidak mendukung fungsi INTERSECT dan MINUS Oracle kecuali untuk fungsi UNION dan UNION ALL:

• UNION: Melampirkan kumpulan hasil yang berisi dua pernyataan SELECT atau lebih dan menghapus data duplikat.
• UNION ALL: Melampirkan kumpulan hasil dari dua pernyataan SELECT atau lebih tanpa menghapus data duplikat.
• INTERSECT: Menampilkan perpotongan dari dua pernyataan SELECT atau lebih hanya jika data ada di kedua set data.
• MINUS: Membandingkan dua atau beberapa pernyataan SELECT, hanya menampilkan baris yang berbeda dari kueri pertama yang tidak ditampilkan oleh pernyataan lainnya.

Catatan konversi

Saat melakukan konversi dari fungsi INTERSECT dan MINUS Oracle ke MySQL, gunakan pernyataan JOIN serta IN dan EXISTS sebagai solusi alternatif.

Contoh

UNION

SELECT COL1 FROM TBL1
UNION
SELECT COL1 FROM TBL2

SELECT COL1 FROM TBL1
UNION
SELECT COL1 FROM TBL2

UNION ALL

SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2

SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2

INTERSECT

SELECT COL1 FROM TBL1
INTERSECT
SELECT COL1 FROM TBL2

SELECT COL1 FROM TBL1
WHERE COL1 IN
(SELECT COL1 FROM TBL2)

MINUS

SELECT COL1 FROM TBL1
MINUS
SELECT COL1 FROM TBL2

SELECT A.COL1
FROM TBL1 A LEFT JOIN TBL2 B
ON USING(COL1)
WHERE B.COL1 IS NULL

Fungsi skalar (baris tunggal) dan grup

MySQL menyediakan daftar lengkap fungsi skalar (baris tunggal) dan agregasi. Beberapa fungsi MySQL mirip dengan fungsi Oracle (berdasarkan nama dan fungsi, atau dengan nama yang berbeda tetapi dengan fungsi yang mirip). Meskipun fungsi MySQL dapat memiliki nama yang identik dengan fungsi Oracle, keduanya dapat menunjukkan fungsionalitas yang berbeda.

Tabel berikut menjelaskan di mana Oracle dan MySQL setara berdasarkan nama dan fungsionalitas (ditentukan oleh "Yes") dan tempat konversi direkomendasikan (semua kasus selain "Yes").

Fungsi karakter

CONCAT(str1,str2)

CONCAT('A', 1) = A1

CONCAT

CONCAT('A', 1) = A1

LOWER/UPPER

LOWER('SQL') = sql

LOWER/UPPER

LOWER('SQL') = sql

LPAD/RPAD(expr1,n,expr2)

LPAD('A',3,'*') = **A

LPAD/RPAD

LPAD('A',3,'*') = **A

SUBSTR(char,p,n)

SUBSTR('MySQL', 3, 3)
= SQL

SUBSTR(char,p,n)

SUBSTR('MySQL', 3, 3)
= SQL

INSTR(index,str)

INSTR('MySQL', 'y')
= 2

INSTR

INSTR('MySQL', 'y')
= 2

REPLACE(char,str1,str2)

REPLACE('ORADB', 'ORA', 'MySQL')


= MySQLDB

REPLACE(char,str1,str2)

REPLACE('ORADB', 'ORA', 'MySQL')


= MySQLDB

TRIM(str)

TRIM(both '-' FROM '-MySQL-')
= MySQL


TRIM('  MySQL ')
= MySQL

TRIM(str)

TRIM(both '-' FROM '-MySQL-')
= MySQL


TRIM('  MySQL ')
= MySQL

LTRIM/RTRIM(str)

LTRIM('   MySQL', ' ')
= MySQL

LTRIM/RTRIM(str)

LTRIM('   MySQL')
= MySQL

ASCII(char)

ASCII('A') = 65

ASCII(char)

ASCII('A') = 65

CHR(char)

CHR(65) = A

CHAR(char)

CHAR(65) = A

LENGTH(str)

LENGTH ('MySQL') = 5

LENGTH(str)

LENGTH('MySQL') = 5

REGEXP_REPLACE(str1,expr,str2)

REGEXP_REPLACE('John', '[hn].', '1') = Jo1

REGEXP_SUBSTR(str,expr)

REGEXP_SUBSTR('https://console.cloud.google.com/sql/instances','https://([[:alnum:]]+\.?){3,4}/?')
= https://console.cloud.google.com/

REGEXP_COUNT(str,expr)

REGEXP_INSTR(index,expr)

REVERSE(str)

REVERSE('MySQL')
= LQSyM

REVERSE

REVERSE('MySQL')
= LQSyM

Fungsi numerik

ABS(n)

ABS(-4.6) = 4.6

ABS

ABS(-4.6) = 4.6

CEIL(n)

CEIL(21.4) = 22

CEIL

CEIL(21.4) = 22

FLOOR(n)

FLOOR(-23.7) = -24

FLOOR

FLOOR(-23.7) = -24

MOD(m,n)

MOD(10, 3) = 1

MOD(m,n)

MOD(10,3) = 1

ROUND(m,n)

ROUND(1.39,1) = 1.4

ROUND

ROUND(1.39,1) = 1.4

TRUNC(n1, n2)

TRUNC(99.999) = 99
TRUNC(99.999,0) = 99

TRUNCATE(n1, n2)

TRUNCATE(99.999,0) = 99

Fungsi tanggal dan waktu

SYSDATE

SELECT SYSDATE
FROM DUAL
= 31-JUL-2019

SYSDATE()

SELECT SYSDATE()
FROM DUAL;
= 2019-01-31 10:01:01.0

SYSTIMESTAMP

SELECT SYSTIMESTAMP FROM DUAL
= 01-JAN-19 07.37.11.622187000 AM +00:00

CURRENT_TIMESTAMP

SELECT CURRENT_TIMESTAMP
FROM DUAL
= 2019-01-31 06:55:07

LOCAL_TIMESTAMP

SELECT LOCAL_TIMESTAMP
FROM DUAL
= 01-JAN-19 10.01.10.123456 PM

LOCAL_TIMESTAMP

SELECT LOCAL_TIMESTAMP
FROM DUAL
= 2019-01-01 10:01:01.0

CURRENT_DATE

SELECT CURRENT_DATE
FROM DUAL
= 31-JAN-19

CURRENT_DATE

SELECT CURRENT_DATE
FROM DUAL
= 2019-01-31

CURRENT_TIMESTAMP

SELECT CURRENT_TIMESTAMP
FROM DUAL
= 31-JAN-19 06.54.35.543146 AM +00:00

CURRENT_TIMESTAMP

SELECT CURRENT_TIMESTAMP
FROM DUAL
= 2019-01-31 06:55:07

ADD_MONTHS

ADD_MONTHS(SYSDATE, 1)
= 31-JAN-19

ADDDATE

ADDDATE(SYSDATE(), 1)
= 2019-08-01 06:42:49.0

EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019

EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019

LAST_DAY

LAST_DAY('01-JAN-2019')
= 31-JAN-19

LAST_DAY

LAST_DAY('2019-01-01')
= 2019-01-31

MONTH_BETWEEN

MONTHS_BETWEEN(
SYSDATE, SYSDATE-60)
= 1.96

PERIOD_DIFF(date1,date2)

PERIOD_DIFF(
'201903', '201901')
= 2

TO_CHAR(
SYSDATE,'DD-MM-YYYY HH24:MI:SS')
= 01-01-2019 10:01:01

DATE_FORMAT

DATE_FORMAT(
SYSDATE(),'%d-%m-%Y %H:%i:%s')
= 01-01-2019 10:01:01

Fungsi encoding dan decoding

DECODE

CASE

DUMP

ORA_HASH

MD5/SHA

Fungsi konversi

CAST

CAST('1' as int) + 1
= 2

CAST

CAST('1' AS SIGNED) + 1
= 2

CONVERT

CONVERT('Ä Ê Í Õ Ø A B C D E ', 'US7ASCII', 'WE8ISO8859P1')
= ?? ?? ?? A B C

CONVERT

CONVERT('Ä Ê Í A B C ' USING utf8)
= Ä Ê Í A B C

TO_CHAR(22.73,'$99.9')
= $22.7

FORMAT

CONCAT('$',
FORMAT(22.73, 1))
= $22.7

TO_DATE

TO_DATE(
'2019/01/01', 'yyyy-mm-dd')
= 01-JAN-2019

STR_TO_DATE

STR_TO_DATE(
'2019/01/01', '%Y/%m/%d')
= 2019-01-01

TO_NUMBER

TO_NUMBER('01234')
= 1234

CAST

CAST('01234' as SIGNED)
= 1234

Fungsi SELECT bersyarat

CASE

CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END

CASE

CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END

Fungsi null

COALESCE

COALESCE(
null, '1', 'a')
= a

COALESCE

COALESCE(
null, '1', 'a')
= 1

NULLIF

NULLIF('1', '2')
= a

NULLIF

NULLIF('1', '2')
= a

NVL

NVL(null, 'a')
= a

IFNULL

IFNULL(null, 'a')
= a

NVL2

CASE

CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END

Fungsi lingkungan dan ID

SYS_GUID

SELECT SYS_GUID()
FROM DUAL
= 8EFA4A31468B4C6DE05011AC0200009E

REPLACE(
UUID(), '-', '')

UID

SELECT UID FROM DUAL
= 43

USER

SELECT USER FROM DUAL
= UserName

USER + INSTR + SUBSTR

SELECT
SUBSTR(USER(), 1, INSTR(USER(), '@') -1) FROM DUAL
= root

USERENV

SELECT USERENV('LANGUAGE')
FROM DUAL
= ENGLISH_AMERICA.AL32UTF8

SHOW SESSION
VARIABLES

SHOW SESSION VARIABLES LIKE '%collation%';
= utf8_general_ci

ROWID

ROWNUM

Fungsi agregat (grup)

AVG

AVG

COUNT

COUNT

COUNT
(DISTINCT)

COUNT
(DISTINCT)

MAX

MAX

MIN

MIN

SUM

SUM

LISTAGG

SELECT LISTAGG(
DEPARTMENT_NAME, ', ')
WITHIN GROUP
(ORDER BY DEPARTMENT_NAME) DEPT
FROM DEPARTMENTS;


-- Single line results


= Accounting, Administration, Benefits, Construction

GROUP_CONCAT

SELECT GROUP_CONCAT(
DEPARTMENT_NAME ORDER BY DEPARTMENT_NAME SEPARATOR ', ') DEPT
FROM DEPARTMENTS;


-- Single line results


= Accounting, Administration, Benefits, Construction

Pengambilan Oracle 12c

FETCH

SELECT * FROM
EMPLOYEES
FETCH FIRST 10 ROWS ONLY;

SELECT * FROM
EMPLOYEES
LIMIT 10;

Pemfilteran dasar, operator, dan subkueri

Selama konversi, pemfilteran dasar, fungsi operator, dan subkueri relatif mudah, sehingga hanya memerlukan sedikit atau tanpa upaya tambahan.

Catatan konversi

Periksa dan tangani format tanggal karena format Oracle dan MySQL menampilkan hasil default yang berbeda:

• Fungsi SYSDATE Oracle secara default menampilkan 01-AUG-19.
• Fungsi SYSDATE() MySQL secara default menampilkan 2019-08-01 12:04:05.
• Format tanggal dan waktu dapat disetel menggunakan fungsi [DATE_FORMAT](https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_date-format) atau [STR_TO_DATE](https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_str-to-date) MySQL.

EXISTS/NOT EXISTS

EXISTS/NOT EXISTS

SELECT * FROM DEPARTMENTS D
WHERE EXISTS (SELECT 1
              FROM EMPLOYEES E
              WHERE
              E.DEPARTMENT_ID =
              D.DEPARTMENT_ID);

IN/NOT IN

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

LIKE/NOT LIKE

SELECT * FROM EMPLOYEES
WHERE FIRST_NAME LIKE '_e_n%';

BETWEEN/NOT BETWEEN

BETWEEN/NOT BETWEEN

SELECT * FROM EMPLOYEES
WHERE EXTRACT(YEAR FROM HIRE_DATE)
NOT BETWEEN 2001 and 2004;

AND/OR

AND/OR

SELECT * FROM EMPLOYEES
WHERE DEPARTMENT_ID IN(100, 101)
AND (SALARY >= 1000 OR HIRE_DATE <= '2006-02-05');

SubQuery

SubQuery

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

> | >= | < | <= | = | <> | !=

Fungsi analisis (atau fungsi jendela dan peringkat)

Fungsi analisis Oracle memperluas fungsionalitas dari fungsi analisis SQL standar dengan menyediakan kemampuan untuk menghitung nilai agregat berdasarkan sekumpulan baris. Fungsi ini dapat diterapkan ke kumpulan hasil yang dipartisi secara logis dalam cakupan ekspresi kueri tunggal. Fungsi ini biasanya digunakan bersama dengan analisis dan laporan business intelligence, dengan potensi untuk meningkatkan performa kueri sebagai alternatif untuk mencapai hasil yang sama menggunakan kode SQL non-analitis yang lebih kompleks.

Catatan konversi

• MySQL versi 5.7 tidak menyediakan fungsi analisis untuk mendukung konversi pernyataan SQL yang mudah. Namun, fungsi ini ditambahkan sebagian di MySQL versi 8, sehingga menjadikan konversi fungsi analisis sebagai hal yang perlu dipertimbangkan, yang mungkin memerlukan upaya manual dalam proses migrasi.
• Solusi opsional adalah menulis ulang kode untuk menghapus penggunaan fungsi analisis, kembali ke solusi kode SQL yang lebih tradisional, atau memindahkan logika ini ke lapisan aplikasi.

Tabel berikut mencantumkan fungsi analisis umum Oracle.

RANK
AVERAGE_RANK
DENSE_RANK
RANK ROW_NUMBER
PERCENT_RANK
CUME_DIST
NTILE
FIRST_VALUE
LAST_VALUE
OVER (PARTITION BY...)

CONNECT BY
HIER_ANCESTOR
HIER_CHILD_COUNT
HIER_DEPTH
HIER_LEVEL
HIER_ORDER
HIER_PARENT
HIER_TOP

LAG
LAG_VARIANCE LAG_VARIANCE_PERCENT LEAD
LEAD_VARIANCE LEAD_VARIANCE_PERCENT

Ekspresi tabel umum (CTE)

CTE menyediakan cara untuk menerapkan logika kode berurutan untuk menggunakan kembali kode SQL yang mungkin terlalu kompleks atau tidak efisien untuk beberapa penggunaan. CTE dapat diberi nama dan digunakan beberapa kali di berbagai bagian pernyataan SQL menggunakan klausul WITH.

Catatan konversi

• MySQL versi 5.7 tidak mendukung CTE, tetapi MySQL versi 8 mendukungnya.
• Untuk solusi alternatif, gunakan tabel turunan atau SubKueri atau tulis ulang pernyataan SQL untuk menghilangkan fungsi CTE.

Contoh

WITH DEPT_COUNT
(DEPARTMENT_ID, DEPT_COUNT) AS
(SELECT DEPARTMENT_ID,
        COUNT(*)
 FROM EMPLOYEES
 GROUP BY DEPARTMENT_ID)


SELECT E.FIRST_NAME ||' '|| E.LAST_NAME AS EMP_NAME,
       D.DEPT_COUNT AS EMP_DEPT_COUNT
FROM EMPLOYEES E JOIN DEPT_COUNT D
USING (DEPARTMENT_ID)
ORDER BY 2 DESC;

SELECT * FROM (
SELECT CONCAT(E.FIRST_NAME, ' ', E.LAST_NAME) AS EMP_NAME,
       (SELECT COUNT(*)
        FROM EMPLOYEES D
        WHERE E.DEPARTMENT_ID = D.DEPARTMENT_ID
        GROUP BY DEPARTMENT_ID) AS EMP_DEPT_COUNT
FROM EMPLOYEES E
ORDER BY 2 DESC) TBL
WHERE EMP_DEPT_COUNT IS NOT NULL;

Pernyataan MERGE

Pernyataan MERGE (atau UPSERT) menyediakan cara untuk menentukan satu pernyataan SQL yang secara kondisional melakukan operasi DML dalam satu operasi MERGE, bukan satu operasi DML, yang berjalan terpisah. Fungsi ini memilih data dari tabel sumber, kemudian, dengan menentukan struktur logis, secara otomatis melakukan beberapa operasi DML pada tabel target. Fitur ini membantu Anda menghindari penggunaan beberapa penyisipan, update, atau penghapusan. Perhatikan bahwa MERGE adalah pernyataan deterministik, yang berarti bahwa setelah sebuah baris diproses oleh pernyataan MERGE, baris tersebut tidak dapat diproses lagi menggunakan pernyataan MERGE yang sama.

Catatan konversi

MySQL versi 5.7 tidak mendukung fungsi MERGE, tidak seperti Oracle. Untuk menyimulasikan sebagianMERGE fungsionalitasnya, MySQL menyediakanREPLACE dan pernyataan INSERT… ON DUPLICATE KEY UPDATE:

• REPLACE: Berfungsi dengan cara yang sama seperti pernyataan INSERT, kecuali jika baris lama dalam tabel memiliki nilai yang sama dengan baris baru untuk PRIMARY KEY atau UNIQUE, baris lama akan dihapus sebelum baris baru disisipkan.

• INSERT… ON DUPLICATE KEY UPDATE: Jika baris yang disisipkan akan menyebabkan nilai duplikat dalam indeks PRIMARY KEY atau UNIQUE, UPDATE dari baris lama akan muncul untuk menghilangkan pengecualian kunci duplikat, misalnya:

  INSERT INTO tbl (a,b,c) VALUES (1,2,3)
    ON DUPLICATE KEY UPDATE c=c+1;
  
  UPDATE tbl SET c=c+1 WHERE a=1;
  

Solusi lainnya adalah mengonversi fungsi MERGE menjadi prosedur tersimpan untuk mengelola operasi DML, menggunakan perintah INSERT, UPDATE, dan DELETE dengan penanganan pengecualian serta duplikasi.

Petunjuk pernyataan SQL

Oracle menyediakan banyak petunjuk kueri SQL yang memungkinkan pengguna memengaruhi perilaku Optimizer dan pengambilan keputusannya, yang bertujuan untuk menghasilkan rencana eksekusi kueri yang lebih efisien. Oracle mendukung lebih dari 60 petunjuk database yang berbeda. MySQL menyediakan kumpulan petunjuk kueri yang terbatas.

Secara umum, MySQL versi 5.7 mendukung dua jenis petunjuk kueri: OPTIMIZER HINTS dan INDEX HINTS. Petunjuk MySQL Optimizer memberikan kemampuan untuk mengontrol perilaku Pengoptimal dalam setiap pernyataan SQL—misalnya:

SELECT /*+ NO_RANGE_OPTIMIZATION(tbl PRIMARY, col1_idx) */ col1 FROM tbl;

MySQL MySQL

BKA, NO_BKA

BNL, NO_BNL

MAX_EXECUTION_TIME

MRR, NO_MRR

NO_ICP

NO_RANGE_OPTIMIZATION

QB_NAME

SEMIJOIN, NO_SEMIJOIN

SUBQUERY

Petunjuk Indeks MySQL memberi Pengoptimal informasi tentang cara memilih indeks selama pemrosesan kueri. Kata kunci USE, FORCE, atau IGNORE digunakan untuk mengontrol proses penggunaan indeks Optimizer—misalnya:

SELECT * FROM tbl USE INDEX (col1_index, col2_index);
-- OR
SELECT * FROM tbl IGNORE INDEX (col1_index, col2_index);

Catatan konversi

Karena ada perbedaan mendasar antara Oracle dan MySQL Optimizer, dan karena ada tumpang-tindih terbatas atau tidak sama sekali antara petunjuk kueri Oracle dan MySQL, sebaiknya Anda mengonversi pernyataan Oracle SQL yang menyimpan petunjuk kueri yang tidak ditentukan ke target database MySQL.

Lakukan penyesuaian performa MySQL melalui alat MySQL (misalnya, Workbench MySQL untuk dasbor performa real-time) dan fitur seperti memeriksa kueri menggunakan rencana eksekusi dan menyesuaikan instance atau parameter sesi sesuai dengan kasus penggunaan.

Rencana eksekusi

Tujuan utama dari rencana eksekusi adalah untuk memberikan gambaran mendalam mengenai pilihan yang dibuat oleh pengoptimal kueri untuk mengakses data database. Pengoptimal kueri akan menghasilkan rencana eksekusi untuk pernyataan SELECT, INSERT, UPDATE, dan DELETE untuk pengguna database, yang juga memungkinkan administrator memiliki pandangan yang lebih baik mengenai kueri tertentu dan operasi DML. Parameter ini sangat berguna saat Anda perlu melakukan penyesuaian performa kueri—misalnya, untuk menentukan performa indeks atau untuk menentukan apakah ada indeks yang hilang yang perlu dibuat.

Rencana eksekusi dapat dipengaruhi oleh volume data, statistik data, dan parameter instance (parameter global atau sesi).

Pertimbangan konversi

Rencana eksekusi bukanlah objek database yang perlu dimigrasikan; melainkan alat untuk menganalisis perbedaan performa antara Oracle dan MySQL yang menjalankan pernyataan yang sama pada set data yang identik.

MySQL tidak mendukung sintaksis, fungsi, atau output rencana eksekusi yang sama dengan Oracle.

Contoh

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  |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+

Prosedur, fungsi, dan pemicu yang tersimpan

PL/SQL adalah bahasa prosedural Oracle yang diperluas yang digunakan untuk membuat, menyimpan, dan menerapkan solusi berbasis kode dalam database. Secara umum, prosedur dan fungsi database yang tersimpan adalah elemen kode yang terdiri dari bahasa prosedural ANSI SQL dan SQL yang diperluas—misalnya, PL/SQL untuk Oracle, PL/pgSQL untuk PostgreSQL, dan bahasa prosedur MySQL untuk MySQL. MySQL menggunakan nama yang sama dengan database untuk bahasa prosedurnya sendiri yang diperluas.

Tujuan dari prosedur dan fungsi yang tersimpan ini adalah memberikan solusi untuk persyaratan yang lebih cocok dijalankan dari dalam database, bukan dari aplikasi (misalnya, performa, kompatibilitas, dan keamanan). Meskipun prosedur dan fungsi tersimpan menggunakan PL/SQL, prosedur tersimpan digunakan terutama untuk melakukan operasi DDL/DML, dan fungsi terutama digunakan untuk melakukan penghitungan guna menampilkan hasil tertentu.

Bahasa prosedur PL/SQL ke MySQL

Dari perspektif migrasi kode Oracle PL/SQL ke MySQL, implementasi prosedural MySQL berbeda dengan Oracle. Oleh karena itu, migrasi kode diperlukan untuk mengonversi fungsi PL/SQL dari Oracle ke prosedur dan fungsi yang tersimpan di MySQL. Selain itu, Paket Oracle dan Isi Paket tidak didukung oleh MySQL, jadi saat Anda melakukan konversi kode, konversikan elemen ini (atau uraikan elemen tersebut) menjadi satu unit kode MySQL. Perhatikan bahwa prosedur dan fungsi yang tersimpan di MySQL jua disebut sebagai rutin.g

Pemilik objek kode

Di Oracle, pemilik prosedur atau fungsi yang tersimpan adalah pengguna tertentu. Di MySQL, pemilik adalah skema spesifik (yang dibuat dalam database oleh pengguna database).

Hak istimewa dan keamanan objek kode

Di Oracle, untuk membuat prosedur atau fungsi tersimpan, pengguna harus memiliki hak istimewa sistem CREATE PROCEDURE (untuk membuat prosedur atau fungsi di bawah pengguna lain, pengguna database harus memiliki hak istimewa CREATE ANY PROCEDURE). Untuk menjalankan prosedur tersimpan atau fungsi, pengguna database harus memiliki hak istimewa EXECUTE.

Di MySQL, untuk membuat elemen kode, pengguna harus memiliki hak istimewa CREATE ROUTINE dan hak istimewa EXECUTE agar dapat berjalan. Klausa DEFINER MySQL menentukan pembuat pengguna untuk objek kode, dan pengguna harus memiliki hak istimewa yang sesuai seperti CREATE ROUTINE.

Prosedur dan sintaksis fungsi tersimpan MySQL

Contoh berikut menunjukkan prosedur dan fungsi yang tersimpan di MySQL syntax .

CREATE
    [DEFINER = user]
    PROCEDURE sp_name ([proc_parameter[,...]])
    [characteristic ...] routine_body

CREATE
    [DEFINER = user]
    FUNCTION sp_name ([func_parameter[,...]])
    RETURNS type
    [characteristic ...] routine_body

proc_parameter:
    [ IN | OUT | INOUT ] param_name type

func_parameter:
    param_name type

type:
    Any valid MySQL data type

characteristic:
    COMMENT 'string'
  | LANGUAGE SQL
  | [NOT] DETERMINISTIC
  | { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
  | SQL SECURITY { DEFINER | INVOKER }

routine_body:
    Valid SQL routine statement