Migrasi dari Oracle ke MySQL/Percona Server bukanlah tugas yang sepele. Meski semakin mudah, apalagi dengan hadirnya MySQL 8.0 dan Percona mengumumkan Percona Server untuk MySQL 8.0 GA. Selain merencanakan migrasi Anda dari Oracle ke Server Percona, Anda harus memastikan bahwa Anda memahami tujuan dan fungsionalitas mengapa harus Server Percona.
Blog ini akan fokus pada Migrasi dari Oracle ke Server Percona sebagai basis data pilihan target spesifiknya. Ada halaman di situs web Oracle tentang Informasi Tambahan Pengembang SQL untuk Migrasi MySQL yang dapat digunakan sebagai referensi untuk migrasi yang direncanakan. Blog ini tidak akan membahas proses migrasi secara keseluruhan, karena merupakan proses yang panjang. Namun, ini diharapkan akan memberikan informasi latar belakang yang cukup untuk menjadi panduan bagi proses migrasi Anda.
Karena Percona Server adalah fork dari MySQL, hampir semua fitur yang ada di MySQL ada di Percona Server. Jadi referensi MySQL di sini juga berlaku untuk Server Percona. Kami sebelumnya membuat blog tentang migrasi Oracle Database ke PostgreSQL. Saya akan mengulangi lagi alasan mengapa seseorang mempertimbangkan untuk bermigrasi dari Oracle ke RDBMS open-source seperti PostgreSQL atau Percona Server/MySQL/MariaDB.
- Biaya:Seperti yang Anda ketahui, biaya lisensi Oracle sangat mahal dan ada biaya tambahan untuk beberapa fitur seperti partisi dan ketersediaan tinggi. Jadi secara keseluruhan itu sangat mahal.
- Lisensi open source yang fleksibel dan ketersediaan yang mudah dari penyedia cloud publik seperti AWS.
- Manfaatkan add-on open source untuk meningkatkan kinerja.
Strategi Perencanaan dan Pengembangan
Migrasi dari Oracle ke Percona Server 8.0 bisa merepotkan karena ada banyak faktor kunci yang perlu dipertimbangkan dan ditangani. Misalnya, Oracle dapat berjalan di mesin Windows Server tetapi Percona Server tidak mendukung Windows. Meskipun Anda dapat mengompilasinya untuk Windows, Percona sendiri tidak menawarkan dukungan apa pun untuk Windows. Anda juga harus mengidentifikasi persyaratan arsitektur database Anda, karena Server Percona tidak dirancang untuk OLAP (Online Analytical Processing) atau aplikasi penyimpanan data. Percona Server/MySQL RDBMS sangat cocok untuk OLTP (Pemrosesan Transaksi Online).
Mengidentifikasi aspek kunci dari arsitektur database Anda, misalnya jika arsitektur Oracle Anda saat ini mengimplementasikan MAA (Maximum Available Architecture) dengan Data Guard ++ Oracle RAC (Real Application Cluster), Anda harus menentukan kesetaraannya di Percona Server. Tidak ada jawaban langsung untuk ini di dalam Server MySQL/Percona. Namun, Anda dapat memilih dari replikasi sinkron, replikasi asinkron (Percona XtraDB Cluster saat ini masih menggunakan versi 5.7.x), atau dengan Replikasi Grup. Lalu, ada beberapa alternatif yang dapat Anda terapkan untuk solusi ketersediaan tinggi Anda sendiri. Misalnya, (untuk beberapa nama) menggunakan tumpukan Corosync/Pacemaker/DRBD/Linux, atau menggunakan MHA (Ketersediaan Tinggi MySQL), atau menggunakan tumpukan Keepalived/HaProxy/ProxySQL, atau hanya mengandalkan ClusterControl yang mendukung Keepalived, HaProxy, ProxySQL, Garbd, dan Maxscale untuk solusi ketersediaan tinggi Anda.
Di sisi lain, pertanyaan yang juga harus Anda pertimbangkan sebagai bagian dari rencana adalah "Bagaimana Percona akan memberikan dukungan dan siapa yang akan membantu kami ketika Server Percona sendiri menemukan bug atau seberapa tinggi urgensi saat kami membutuhkan bantuan?". Satu hal yang perlu dipertimbangkan juga adalah anggaran, jika tujuan migrasi dari database perusahaan ke RDBMS open-source adalah karena pemotongan biaya.
Ada berbagai opsi mulai dari perencanaan migrasi hingga hal-hal yang perlu Anda lakukan sebagai bagian dari strategi pengembangan Anda. Pilihan tersebut termasuk terlibat dengan para ahli di bidang MySQL/Percona Server dan itu termasuk kami di sini di Beberapa. Ada banyak perusahaan konsultan MySQL yang dapat membantu Anda melalui ini karena migrasi dari Oracle ke MySQL membutuhkan banyak keahlian dan pengetahuan di bidang Server MySQL. Ini tidak boleh terbatas pada database tetapi harus mencakup keahlian dalam skalabilitas, redundansi, pencadangan, ketersediaan tinggi, keamanan, pemantauan/observabilitas, pemulihan, dan keterlibatan dalam sistem kritis misi. Secara keseluruhan, itu harus memiliki pemahaman tentang wawasan arsitektur Anda tanpa mengungkapkan kerahasiaan data Anda.
Penilaian atau Pemeriksaan Awal
Mencadangkan data Anda termasuk file konfigurasi atau pengaturan, penyetelan kernel, skrip otomatisasi tidak boleh dilupakan. Ini adalah tugas yang jelas, tetapi sebelum Anda bermigrasi, selalu amankan semuanya terlebih dahulu , terutama saat pindah ke platform yang berbeda.
Anda juga harus menilai bahwa aplikasi Anda mengikuti konvensi rekayasa perangkat lunak terkini dan memastikan bahwa mereka adalah platform agnostik. Praktik ini dapat bermanfaat bagi Anda terutama saat berpindah ke platform database yang berbeda, seperti Server Percona untuk MySQL.
Perhatikan bahwa sistem operasi yang dibutuhkan Server Percona dapat menjadi penghalang jika aplikasi dan database Anda berjalan di Server Windows dan aplikasi tersebut bergantung pada Windows; maka ini bisa menjadi banyak pekerjaan! Selalu ingat bahwa Server Percona berada pada platform yang berbeda:kesempurnaan mungkin tidak dijamin tetapi dapat dicapai cukup dekat.
Terakhir, pastikan bahwa perangkat keras yang ditargetkan dirancang untuk bekerja secara layak dengan persyaratan server Percona atau setidaknya bebas bug (lihat di sini). Anda dapat mempertimbangkan pengujian stres terlebih dahulu dengan Percona Server sebelum secara andal pindah dari Oracle Database Anda.
Yang Harus Anda Ketahui
Perlu dicatat bahwa di Percona Server / MySQL, Anda dapat membuat beberapa database sedangkan Oracle tidak datang dengan fungsi yang sama seperti MySQL.
Di MySQL, secara fisik, skema identik dengan database. Anda dapat mengganti kata kunci SCHEMA sebagai ganti DATABASE dalam sintaks SQL MySQL, misalnya menggunakan CREATE SCHEMA bukannya CREATE DATABASE; sementara Oracle memiliki perbedaan dalam hal ini. Skema hanya mewakili sebagian dari database:tabel dan objek lain yang dimiliki oleh satu pengguna. Biasanya, ada hubungan satu-ke-satu antara instance dan database.
Misalnya, dalam pengaturan replikasi yang setara di Oracle (mis. Real Application Clusters atau RAC), Anda memiliki beberapa instans yang mengakses satu database. Ini memungkinkan Anda memulai Oracle di beberapa server, tetapi semuanya mengakses data yang sama. Namun, di MySQL, Anda dapat mengizinkan akses ke beberapa database dari beberapa instance Anda dan bahkan dapat memfilter database/skema mana yang dapat Anda tiru ke node MySQL.
Merujuk dari salah satu blog kami sebelumnya, prinsip yang sama berlaku ketika berbicara tentang mengonversi database Anda dengan alat yang tersedia di internet.
Tidak ada alat seperti itu yang dapat 100% mengubah database Oracle menjadi Percona Server / MySQL; beberapa di antaranya akan menjadi pekerjaan manual.
Lihat bagian berikut untuk mengetahui hal-hal yang harus Anda ketahui saat melakukan migrasi dan memverifikasi hasil SQL logis.
Pemetaan Tipe Data
MySQL/Percona Server memiliki sejumlah tipe data yang hampir sama dengan Oracle tetapi tidak sekaya dibandingkan dengan Oracle. Tapi sejak kedatangan versi 5.7.8 MySQL, mendukung untuk tipe data JSON asli.
Di bawah ini adalah representasi setara tipe datanya (representasi tabel diambil dari sini):
| Oracle | MySQL | |||
|---|---|---|---|---|
| 1 | BFILE | Penunjuk ke file biner, 4G | VARCHAR(255) | |
| 2 | BINARY_FLOAT | Angka floating-point 32-bit | FLOAT | |
| 3 | BINARY_DOUBLE | Angka floating-point 64-bit | GANDA | |
| 4 | BLOB | Objek besar biner, 4G | LONGBLOB | |
| 5 | CHAR(n), CHARACTER(n) | String dengan panjang tetap, 1 n 255 | CHAR(n), CHARACTER(n) | |
| 6 | CHAR(n), CHARACTER(n) | String dengan panjang tetap, 256 n 2000 | VARCHAR(n) | |
| 7 | CLOB | Karakter objek besar, 4G | TEKS PANJANG | |
| 8 | TANGGAL | Tanggal dan waktu | DATETIME | |
| 9 | DECIMAL(p,s), DEC(p,s) | Nomor poin tetap | DECIMAL(p,s), DEC(p,s) | |
| 10 | PRESISI GANDA | Angka titik-mengambang | PRESISI GANDA | |
| 11 | FLOAT(p) | Angka titik-mengambang | GANDA | |
| 12 | INTEGER, INT | 38 digit bilangan bulat | INT | DESIMAL(38) |
| 13 | INTERVAL TAHUN(p) SAMPAI BULAN | Interval tanggal | VARCHAR(30) | |
| 14 | INTERVAL HARI(p) HINGGA DETIK | Interval hari dan waktu | VARCHAR(30) | |
| 15 | PANJANG | Data karakter, 2G | TEKS PANJANG | |
| 16 | BAKU PANJANG | Data biner, 2G | LONGBLOB | |
| 17 | NCHAR(n) | String UTF-8 dengan panjang tetap, 1 n 255 | NCHAR(n) | |
| 18 | NCHAR(n) | String UTF-8 dengan panjang tetap, 256 n 2000 | NVARCHAR(n) | |
| 19 | VARIASI NCHAR(n) | String UTF-8 dengan panjang bervariasi, 1 n 4000 | NCHAR VARIASI(n) | |
| 20 | NCLOB | String Unicode dengan panjang variabel, 4G | NVARCHAR(maks) | |
| 21 | NUMBER(p,0), NUMBER(p) | Integer 8-bit, 1 <=p <3 | TINYINT | (0 hingga 255) |
| Integer 16-bit, 3 <=p <5 | KECIL | |||
| Integer 32-bit, 5 <=p <9 | INT | |||
| Integer 64-bit, 9 <=p <19 | BESAR | |||
| Angka titik tetap, 19 <=p <=38 | DECIMAL(p) | |||
| 22 | NUMBER(p,s) | Angka titik tetap, s> 0 | DECIMAL(p,s) | |
| 23 | NUMBER, NUMBER(*) | Angka titik-mengambang | GANDA | |
| 24 | NUMERIK(p,s) | Nomor poin tetap | NUMERIK(p,s) | |
| 25 | NVARCHAR2(n) | String UTF-8 dengan panjang variabel, 1 n 4000 | NVARCHAR(n) | |
| 26 | RAW(n) | String biner dengan panjang variabel, 1 n 255 | BINARY(n) | |
| 27 | RAW(n) | String biner dengan panjang variabel, 256 n 2000 | VARBINARY(n) | |
| 28 | NYATA | Angka titik-mengambang | GANDA | |
| 29 | ROWID | Alamat baris fisik | CHAR(10) | |
| 30 | KECIL | 38 digit bilangan bulat | DECIMAL(38) | |
| 31 | TIMESTAMP(p) | Tanggal dan waktu dengan pecahan | DATETIME(p) | |
| 32 | TIMESTAMP(p) DENGAN ZONA WAKTU | Tanggal dan waktu dengan pecahan dan zona waktu | DATETIME(p)  | |
| 33 | UROWID(n) | Alamat baris logis, 1 n ⇐ 4000 | VARCHAR(n) | |
| 34 | VARCHAR(n) | String dengan panjang variabel, 1 n 4000 | VARCHAR(n) | |
| 35 | VARCHAR2(n) | String dengan panjang variabel, 1 n 4000 | VARCHAR(n) | |
| 36 | XMLTYPE | data XML | TEKS PANJANG | |
Atribut dan opsi tipe data:
| Oracle | MySQL |
| semantik ukuran kolom BYTE dan CHAR | Ukuran selalu dalam karakter |
Transaksi
Server Percona menggunakan XtraDB (versi InnoDB yang disempurnakan) sebagai mesin penyimpanan utamanya untuk menangani data transaksional; meskipun berbagai storage engine dapat menjadi pilihan alternatif untuk menangani transaksi seperti TokuDB (deprecated) dan storage engine MyRocks.
Meskipun ada keuntungan dan manfaat menggunakan atau menjelajahi MyRocks dengan XtraDB, yang terakhir lebih kuat dan mesin penyimpanan de facto yang digunakan Server Percona dan diaktifkan secara default, jadi kami akan menggunakan mesin penyimpanan ini sebagai dasar untuk migrasi sehubungan dengan untuk transaksi.
Secara default, Percona Server / MySQL memiliki variabel autocommit yang disetel ke ON yang berarti Anda harus secara eksplisit menangani pernyataan transaksional untuk memanfaatkan ROLLBACK untuk mengabaikan perubahan atau memanfaatkan SAVEPOINT.
Ini pada dasarnya adalah konsep yang sama yang digunakan Oracle dalam hal commit, rollback, dan savepoints.
Untuk transaksi eksplisit, ini berarti Anda harus menggunakan MULAI TRANSAKSI/MULAI;
Jika tidak, jika Anda harus menonaktifkan autocommit, Anda harus secara eksplisit COMMIT sepanjang waktu untuk pernyataan Anda yang memerlukan perubahan pada data Anda.
Tabel Ganda
MySQL memiliki kompatibilitas ganda dengan Oracle yang dimaksudkan untuk kompatibilitas database menggunakan tabel dummy, yaitu DUAL.
Ini sesuai dengan penggunaan DUAL Oracle sehingga pernyataan apa pun yang ada di aplikasi Anda yang menggunakan DUAL mungkin tidak memerlukan perubahan saat migrasi ke Server Percona.
Klausa Oracle FROM wajib untuk setiap pernyataan SELECT, jadi database Oracle menggunakan tabel DUAL untuk pernyataan SELECT di mana nama tabel tidak diperlukan.
Di MySQL, klausa FROM tidak wajib sehingga tabel DUAL tidak diperlukan. Namun, tabel DUAL tidak bekerja sama persis seperti pada Oracle, tetapi untuk SELECT sederhana di Server Percona, ini tidak masalah.
Lihat contoh berikut di bawah ini:
Di Oracle,
SQL> DESC DUAL;
Name Null? Type
----------------------------------------- -------- ----------------------------
DUMMY VARCHAR2(1)
SQL> SELECT CURRENT_TIMESTAMP FROM DUAL;
CURRENT_TIMESTAMP
---------------------------------------------------------------------------
16-FEB-19 04.16.18.910331 AM +08:00Tapi di MySQL:
mysql> DESC DUAL;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'DUAL' at line 1
mysql> SELECT CURRENT_TIMESTAMP FROM DUAL;
+---------------------+
| CURRENT_TIMESTAMP |
+---------------------+
| 2019-02-15 20:20:28 |
+---------------------+
1 row in set (0.00 sec)Catatan:DESC DUAL sintaks tidak berfungsi di MySQL dan hasilnya juga berbeda karena CURRENT_TIMESTAMP (menggunakan tipe data TIMESTAMP) di MySQL tidak menyertakan zona waktu.
SYSDATE
Fungsi SYSDATE Oracle hampir sama di MySQL.
MySQL mengembalikan tanggal dan waktu dan merupakan fungsi yang memerlukan () (tutup dan kurung buka tanpa argumen yang diperlukan. Untuk mendemonstrasikannya di bawah, inilah Oracle dan MySQL dalam menggunakan SYSDATE.
Di Oracle, menggunakan SYSDATE biasa hanya mengembalikan tanggal hari tanpa waktu. Tetapi untuk mendapatkan waktu dan tanggal, gunakan TO_CHAR untuk mengubah waktu tanggal menjadi format yang diinginkan; sedangkan di MySQL, Anda mungkin tidak memerlukannya untuk mendapatkan tanggal dan waktu karena keduanya mengembalikan.
Lihat contoh di bawah.
Di Oracle:
SQL> SELECT TO_CHAR (SYSDATE, 'MM-DD-YYYY HH24:MI:SS') "NOW" FROM DUAL;
NOW
-------------------
02-16-2019 04:39:00
SQL> SELECT SYSDATE FROM DUAL;
SYSDATE
---------
16-FEB-19Tapi di MySQL:
mysql> SELECT SYSDATE() FROM DUAL;
+---------------------+
| SYSDATE() |
+---------------------+
| 2019-02-15 20:37:36 |
+---------------------+
1 row in set (0.00 sec)Jika Anda ingin memformat tanggal, MySQL memiliki fungsi DATE_FORMAT().
Anda dapat memeriksa dokumentasi Tanggal dan Waktu MySQL untuk info lebih lanjut.
TO_DATE
Setara TO_DATE Oracle di MySQL adalah fungsi STR_TO_DATE().
Ini hampir identik dengan yang ada di Oracle:mengembalikan tipe data DATE, sedangkan di MySQL mengembalikan tipe data DATETIME.
Oracle:
SQL> SELECT TO_DATE ('20190218121212','yyyymmddhh24miss') as "NOW" FROM DUAL;
NOW
-------------------------
18-FEB-19MySQL:
mysql> SELECT STR_TO_DATE('2019-02-18 12:12:12','%Y-%m-%d %H:%i:%s') as "NOW" FROM DUAL;
+---------------------+
| NOW |
+---------------------+
| 2019-02-18 12:12:12 |
+---------------------+
1 row in set (0.00 sec)SINONIM
Di MySQL, tidak ada dukungan atau kesetaraan untuk SYNONYM di Oracle.
Alternatif yang mungkin dapat dilakukan dengan MySQL adalah menggunakan VIEW.
Meskipun SYNONYM dapat digunakan untuk membuat alias dari tabel jarak jauh,
misalnya
CREATE PUBLIC SYNONYM emp_table FOR [email protected]Di MySQL, Anda dapat memanfaatkan mesin penyimpanan FEDERATED.
misalnya
CREATE TABLE hr_employees (
id INT(20) NOT NULL AUTO_INCREMENT,
name VARCHAR(32) NOT NULL DEFAULT '',
other INT(20) NOT NULL DEFAULT '0',
PRIMARY KEY (id),
INDEX name (name),
INDEX other_key (other)
)
ENGINE=FEDERATED
DEFAULT CHARSET=utf8mb4
CONNECTION='mysql://[email protected]_host:9306/federated/test_table';Atau Anda dapat menyederhanakan prosesnya dengan sintaks CREATE SERVER, sehingga ketika membuat tabel yang bertindak sebagai SYNONYM Anda untuk mengakses tabel jarak jauh, akan lebih mudah. Lihat dokumentasi untuk info lebih lanjut tentang ini.
Perilaku String Kosong dan NULL
Perhatikan bahwa di Percona Server / MySQL, string kosong bukan NULL sedangkan Oracle memperlakukan string kosong sebagai nilai null.
Di Oracle:
SQL> SELECT CASE WHEN '' IS NULL THEN 'Yes' ELSE 'No' END AS "Null Eval" FROM dual;
Nul
---
YesDi MySQL:
mysql> SELECT CASE WHEN '' IS NULL THEN 'Yes' ELSE 'No' END AS "Null Eval" FROM dual;
+-----------+
| Null Eval |
+-----------+
| No |
+-----------+
1 row in set (0.00 sec)Urutan
Di MySQL, tidak ada pendekatan yang sama persis dengan apa yang dilakukan Oracle untuk SEQUENCE.
Meskipun ada beberapa posting yang mensimulasikan fungsionalitas dari pendekatan ini, Anda mungkin dapat mencoba untuk mendapatkan kunci berikutnya menggunakan LAST_INSERT_ID() selama indeks berkerumun tabel Anda, KUNCI UTAMA, didefinisikan dengan <
Tidak seperti Oracle, MySQL / Percona Server memiliki beberapa fungsi string tetapi tidak banyak fungsi membantu yang ada di dalam database.
Akan terlalu panjang untuk membahasnya satu per satu di sini, tetapi Anda dapat memeriksa dokumentasi dari MySQL dan membandingkannya dengan fungsi string Oracle.
Menyisipkan/Memperbarui/Menghapus pernyataan dari Oracle sesuai di MySQL.
Oracle INSERT ALL/INSERT FIRST tidak didukung di MySQL.
Jika tidak, Anda harus menyatakan kueri MySQL Anda satu per satu.
misalnya
Di Oracle:
2 baris dibuat.
Tapi di MySQL, Anda harus menjalankan insert satu per satu:
INSERT ALL/INSERT FIRST tidak dapat dibandingkan dengan cara penggunaannya di Oracle, di mana Anda dapat memanfaatkan kondisi dengan menambahkan kata kunci WHEN dalam sintaks Anda; tidak ada opsi yang setara di MySQL / Server Percona dalam kasus ini.
Oleh karena itu, solusi alternatif Anda dalam hal ini adalah menggunakan prosedur.
Di Oracle, penggunaan + operator untuk gabungan kiri dan kanan tidak didukung saat ini di MySQL karena operator + hanya digunakan untuk keputusan aritmatika.
Oleh karena itu, jika Anda memiliki + operator dalam pernyataan Oracle SQL yang ada, Anda perlu menggantinya dengan LEFT JOIN atau RIGHT JOIN.
Anda mungkin ingin memeriksa dokumentasi resmi untuk "Penyederhanaan Gabung Luar" MySQL.
Oracle menggunakan START WITH..CONNECT BY untuk kueri hierarkis.
Dimulai dengan MySQL / Percona 8.0, ada dukungan untuk menghasilkan hasil data hierarkis yang menggunakan model seperti daftar adjacency atau model kumpulan bersarang. Ini disebut Common Table Expressions (CTE) di MySQL.
Mirip dengan PostgreSQL, MySQL menggunakan DENGAN RECURSIVE sintaks untuk kueri hierarkis, jadi terjemahkan CONNECT BY pernyataan menjadi DENGAN RECURSIVE pernyataan.
Lihat di bawah tentang perbedaannya dari ORACLE dan di Server MySQL / Percona.
Di Oracle:
Dan di MySQL:
MySQL / Percona RDBMS memiliki pendekatan yang berbeda dari PL/SQL Oracle.
MySQL menggunakan prosedur tersimpan atau fungsi tersimpan, yang mirip dengan PL/SQL dan sintaks menggunakan BEGIN..END sintaks.
PL/SQL Oracle dikompilasi sebelum dieksekusi saat dimuat ke server, sedangkan MySQL dikompilasi dan disimpan dalam cache saat dipanggil.
Anda mungkin ingin memeriksa dokumentasi ini sebagai panduan referensi untuk mengonversi PL/SQL Anda ke MySQL.
Saya melakukan riset untuk alat apa pun yang dapat menjadi standar de facto untuk migrasi, tetapi saya tidak dapat menemukan jawaban yang tepat.
Padahal, saya memang menemukan sqlines dan kelihatannya sederhana namun menjanjikan.
Meskipun saya tidak mendalaminya, situs web ini menawarkan beberapa wawasan, yang dapat membantu Anda bermigrasi dari Oracle ke Server MySQL/Percona. Ada juga alat berbayar seperti ini dan ini.
Saya juga telah mencari melalui github tetapi tidak menemukan yang lebih menarik sebagai solusi untuk masalah tersebut. Oleh karena itu, jika Anda ingin bermigrasi dari Oracle dan ke Amazon, mereka memiliki Alat Konversi Skema AWS yang mendukung migrasi dari Oracle ke MySQL.
Secara keseluruhan, alasan mengapa migrasi bukanlah hal yang mudah untuk dilakukan terutama karena Oracle RDBMS adalah monster dengan banyak fitur yang masih belum dimiliki oleh Percona Server / MySQL atau MariaDB RDBMS.
Bagaimanapun, jika Anda menemukan atau mengetahui alat apa pun yang menurut Anda berguna dan bermanfaat untuk bermigrasi dari Oracle ke Server MySQL / Percona, silakan tinggalkan komentar di blog ini!
Sebagai bagian dari rencana migrasi Anda, pengujian adalah tugas vital yang memainkan peran yang sangat penting dan memengaruhi keputusan Anda terkait migrasi.
Alat dbdeployer (port dari MySQL Sandbox) adalah alat yang sangat membantu yang dapat Anda manfaatkan. Ini cukup mudah bagi Anda untuk mencoba dan menguji berbagai pendekatan dan menghemat waktu Anda, daripada menyiapkan seluruh tumpukan jika tujuan Anda adalah mencoba dan menguji platform RDBMS terlebih dahulu.
Untuk menguji rutinitas tersimpan SQL Anda (fungsi atau prosedur), pemicu, peristiwa, saya sarankan Anda menggunakan alat ini mytap atau Kerangka Pengujian Unit Google.
Percona juga menawarkan sejumlah alat yang tersedia untuk diunduh di situs web mereka. Lihat Percona Toolkit di sini. Anda dapat memilih alat sesuai dengan kebutuhan Anda terutama untuk tugas pengujian dan penggunaan produksi.
Secara keseluruhan, hal-hal yang perlu Anda ingat sebagai pedoman Anda saat melakukan pengujian untuk Server MySQL Anda adalah:Fungsi String Karakter
Pernyataan DML
SQL> INSERT ALL
INTO CUSTOMERS (customer_id, customer_name, city) VALUES (1000, 'Jase Alagaban', 'Davao City')
INTO CUSTOMERS (customer_id, customer_name, city) VALUES (2000, 'Maximus Aleksandre Namuag', 'Davao City')
SELECT * FROM dual;
2 rows created.mysql> INSERT INTO CUSTOMERS (customer_id, customer_name, city) VALUES (1000, 'Jase Alagaban', 'Davao City');
Query OK, 1 row affected (0.02 sec)
mysql> INSERT INTO CUSTOMERS (customer_id, customer_name, city) VALUES (2000, 'Maximus Aleksandre Namuag', 'Davao City');
Query OK, 1 row affected (0.00 sec)Luar Bergabung dengan Simbol "+"
MULAI DENGAN..HUBUNGI DENGAN
SELECT cp.id, cp.title, CONCAT(c2.title, ' > ' || cp.title) as path
FROM category cp INNER JOIN category c2
ON cp.parent_id = c2.id
WHERE cp.parent_id IS NOT NULL
START WITH cp.id >= 1
CONNECT BY NOCYCLE PRIOR c2.id=cp.parent_id; WITH RECURSIVE category_path (id, title, path) AS
(
SELECT id, title, title as path
FROM category
WHERE parent_id IS NULL
UNION ALL
SELECT c.id, c.title, CONCAT(cp.path, ' > ', c.title)
FROM category_path AS cp JOIN category AS c
ON cp.id = c.parent_id
)
SELECT * FROM category_path
ORDER BY path;PL/SQL di MySQL / Percona?
Alat Migrasi
Pengujian
