Hoe te migreren van Oracle naar MySQL / Percona Server

Transacties

Percona Server gebruikt XtraDB (een verbeterde versie van InnoDB) als primaire opslagengine voor het verwerken van transactiegegevens; hoewel verschillende storage-engines een alternatieve keuze kunnen zijn voor het afhandelen van transacties, zoals TokuDB (verouderd) en MyRocks storage-engines.

Hoewel er voordelen en voordelen zijn aan het gebruiken of verkennen van MyRocks met XtraDB, is de laatste een robuustere en de facto opslagengine die Percona Server gebruikt en is deze standaard ingeschakeld, dus we zullen deze opslagengine gebruiken als basis voor migratie met betrekking tot naar transacties.

Percona Server / MySQL heeft standaard de autocommit-variabele ingesteld op AAN, wat betekent dat u expliciet transactie-overzichten moet afhandelen om ROLLBACK te gebruiken voor het negeren van wijzigingen of om te profiteren van het gebruik van SAVEPOINT.

Het is eigenlijk hetzelfde concept dat Oracle gebruikt in termen van commit, rollbacks en savepoints.

Voor expliciete transacties betekent dit dat u de START TRANSACTIE/BEGIN; ; COMMIT; syntaxis.

Anders, als u autocommit moet uitschakelen, moet u zich altijd expliciet COMMIT geven voor uw verklaringen waarvoor wijzigingen in uw gegevens nodig zijn.

Dubbele tafel

MySQL heeft de dubbele compatibiliteit met Oracle die bedoeld is voor compatibiliteit van databases die een dummytabel gebruiken, namelijk DUAL.

Dit past bij Oracle's gebruik van DUAL, dus bestaande instructies in uw applicatie die DUAL gebruiken, hoeven bij migratie naar Percona Server mogelijk niet te worden gewijzigd.

De Oracle FROM-clausule is verplicht voor elke SELECT-instructie, dus Oracle-database gebruikt DUAL-tabel voor SELECT-instructie waar een tabelnaam niet vereist is.

In MySQL is de FROM-component niet verplicht, dus een DUAL-tabel is niet nodig. De DUAL-tabel werkt echter niet precies hetzelfde als voor Oracle, maar voor eenvoudige SELECT's in Percona Server is dit prima.

Zie het volgende voorbeeld hieronder:

In 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:00

Maar in 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)

Opmerking:de DESC DUAL syntaxis werkt niet in MySQL en de resultaten verschillen ook, aangezien CURRENT_TIMESTAMP (gebruikt TIMESTAMP-gegevenstype) in MySQL de tijdzone niet bevat.

SYSDATUM

De SYSDATE-functie van Oracle is bijna hetzelfde in MySQL.

MySQL retourneert datum en tijd en is een functie die () vereist (haakjes sluiten en openen zonder argumenten. Om dit hieronder te demonstreren, volgen hier Oracle en MySQL over het gebruik van SYSDATE.

In Oracle retourneert het gebruik van gewone SYSDATE alleen de datum van de dag zonder de tijd. Maar om de tijd en datum te krijgen, gebruik TO_CHAR om de datum-tijd om te zetten in het gewenste formaat; terwijl je het in MySQL misschien niet nodig hebt om de datum en de tijd te krijgen, omdat het beide retourneert.

Zie voorbeeld hieronder.

In Orakel:

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

Maar in MySQL:

mysql> SELECT SYSDATE() FROM DUAL;
+---------------------+
| SYSDATE()           |
+---------------------+
| 2019-02-15 20:37:36 |
+---------------------+
1 row in set (0.00 sec)

Als je de datum wilt formatteren, heeft MySQL een DATE_FORMAT()-functie.

U kunt de MySQL-documentatie over datum en tijd raadplegen voor meer informatie.

TO_DATE

Oracle's TO_DATE-equivalent in MySQL is de STR_TO_DATE()-functie.

Het is bijna identiek aan die in Oracle:het retourneert het DATE-gegevenstype, terwijl het in MySQL het DATETIME-gegevenstype retourneert.

Orakel:

SQL> SELECT TO_DATE ('20190218121212','yyyymmddhh24miss') as "NOW" FROM DUAL; 
NOW
-------------------------
18-FEB-19

MySQL:

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)

SYNONIEM

In MySQL is er geen dergelijke ondersteuning of gelijkwaardigheid voor SYNONYM in Oracle.

Een mogelijk alternatief dat mogelijk is met MySQL is het gebruik van VIEW.

Hoewel SYNONYM kan worden gebruikt om een ​​alias van een externe tabel te maken,

bijv.

CREATE PUBLIC SYNONYM emp_table FOR [email protected]

In MySQL kunt u profiteren van het gebruik van FEDERATED storage engine.

bijv.

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

Of u kunt het proces vereenvoudigen met de CREATE SERVER-syntaxis, zodat het gemakkelijker wordt wanneer u een tabel maakt die fungeert als uw SYNONIEM voor toegang tot een externe tabel. Zie de documentatie voor meer informatie hierover.

Gedrag van lege string en NULL

Houd er rekening mee dat in Percona Server / MySQL een lege tekenreeks niet NULL is, terwijl Oracle een lege tekenreeks als null-waarden behandelt.

In Orakel:

SQL> SELECT CASE WHEN '' IS NULL THEN 'Yes' ELSE 'No' END AS "Null Eval" FROM dual;
Nul
---
Yes

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

Sequenties

In MySQL is er niet exact dezelfde benadering van wat Oracle doet voor SEQUENCE.

Hoewel er enkele berichten zijn die de functionaliteit van deze benadering simuleren, kunt u misschien proberen de volgende sleutel te krijgen met LAST_INSERT_ID() zolang de geclusterde index van uw tabel, PRIMARY KEY, is gedefinieerd met <>

Tekenreeksfuncties

In tegenstelling tot Oracle heeft MySQL / Percona Server een handvol stringfuncties, maar niet zo veel handige functies die in de database zijn ingebouwd.

Het zou te lang zijn om het hier één voor één te bespreken, maar u kunt de documentatie van MySQL raadplegen en dit vergelijken met de stringfuncties van Oracle.

DML-verklaringen

Insert/Update/Delete statements van Oracle zijn congruent in MySQL.

Oracle's INSERT ALL/INSERT FIRST wordt niet ondersteund in MySQL.

Anders moet u uw MySQL-query's één voor één opgeven.

bijv.

In Orakel:

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.

2 rijen gemaakt.

Maar in MySQL moet u de invoegtoepassing één voor één uitvoeren:

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)

De INSERT ALL/INSERT FIRST is niet te vergelijken met hoe het wordt gebruikt in Oracle, waar u kunt profiteren van voorwaarden door een WHEN-sleutelwoord in uw syntaxis toe te voegen; er is in dit geval geen gelijkwaardige optie in MySQL / Percona Server.

Daarom is uw alternatieve oplossing hiervoor het gebruik van procedures.

Buitenste joins "+"-symbool

In Oracle wordt het gebruik van de operator + voor links en rechts momenteel niet ondersteund in MySQL, omdat de operator + alleen wordt gebruikt voor rekenkundige beslissingen.

Als u de operator + heeft in uw bestaande Oracle SQL-instructies, moet u deze dus vervangen door LEFT JOIN of RIGHT JOIN.

Misschien wil je de officiële documentatie voor "Outer Join Simplification" van MySQL raadplegen.

BEGIN MET..VERBINDEN DOOR

Oracle gebruikt START WITH..CONNECT BY voor hiërarchische queries.

Vanaf MySQL / Percona 8.0 is er ondersteuning voor het genereren van hiërarchische gegevensresultaten die gebruikmaken van modellen zoals adjacency list of geneste set-modellen. Dit heet Common Table Expressions (CTE) in MySQL.

Net als bij PostgreSQL, gebruikt MySQL MET RECURSIEVE syntaxis voor hiërarchische zoekopdrachten, dus vertaal VERBINDEN DOOR statement in MET RECURSIEVE verklaring.

Bekijk hieronder hoe het verschilt van ORACLE en in MySQL / Percona Server.

In Orakel:

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; 

En in MySQL:

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 in MySQL / Percona?

MySQL / Percona RDBMS heeft een andere aanpak dan Oracle's PL/SQL.

MySQL gebruikt opgeslagen procedures of opgeslagen functies, vergelijkbaar met PL/SQL en syntaxis met BEGIN..END syntaxis.

Oracle's PL/SQL wordt gecompileerd voordat het wordt uitgevoerd wanneer het in de server wordt geladen, terwijl MySQL wordt gecompileerd en opgeslagen in de cache wanneer het wordt aangeroepen.

Misschien wilt u deze documentatie bekijken als referentiegids voor het converteren van uw PL/SQL naar MySQL.

Migratietools

Ik heb wat onderzoek gedaan naar tools die een de facto standaard voor migratie zouden kunnen zijn, maar ik kon geen goed antwoord vinden.

Ik heb echter wel sqlines gevonden en het ziet er eenvoudig maar veelbelovend uit.

Hoewel ik er niet diep in ben gedoken, biedt de website een handvol inzichten die je kunnen helpen bij het migreren van Oracle naar MySQL/Percona Server. Er zijn ook betaalde tools zoals deze en deze.

Ik heb ook door github gezocht, maar vond niets veel aantrekkelijker als een oplossing voor het probleem. Als u dus van Oracle naar Amazon wilt migreren, hebben ze AWS Schema Conversion Tool waarvoor migratie van Oracle naar MySQL wordt ondersteund.

Over het algemeen is de reden waarom migratie niet eenvoudig is, vooral omdat Oracle RDBMS zo'n beest is met veel functies die Percona Server / MySQL of MariaDB RDBMS nog steeds niet hebben.

Hoe dan ook, als u tools vindt of kent die u nuttig en nuttig vindt voor het migreren van Oracle naar MySQL / Percona Server, laat dan alstublieft een reactie achter op deze blog!

Testen

Als onderdeel van uw migratieplan is testen een essentiële taak die een zeer belangrijke rol speelt en van invloed is op uw beslissing met betrekking tot migratie.

De tool dbdeployer (een poort van MySQL Sandbox) is een zeer handige tool waar je je voordeel mee kunt doen. Dit is vrij eenvoudig voor u om verschillende benaderingen te proberen en te testen en bespaart u tijd, in plaats van de hele stapel in te stellen als het uw doel is om eerst het RDBMS-platform te testen.

Voor het testen van uw in SQL opgeslagen routines (functies of procedures), triggers, gebeurtenissen, raad ik u aan deze tools mytap of het Unit Testing Framework van Google te gebruiken.

Percona biedt ook een aantal tools die beschikbaar zijn om te downloaden op hun website. Bekijk hier de Percona Toolkit. U kunt de tools kiezen op basis van uw behoeften, met name voor test- en productiegebruikstaken.

Over het algemeen zijn dingen die u in gedachten moet houden als uw richtlijnen bij het doen van een test voor uw MySQL-server:

• Na je installatie moet je overwegen om af te stemmen. Bekijk deze Percona-blog voor hulp.
• Doe een aantal benchmarks en stress-load-tests voor uw configuratie-instellingen op uw huidige node. Check mysqlslap en sysbench die je hierbij kunnen helpen. Bekijk ook onze blog "Hoe de prestaties van MySQL &MariaDB te benchmarken met SysBench".
• Controleer uw DDL's of ze correct zijn gedefinieerd, zoals gegevenstypes, beperkingen, geclusterde en secundaire indexen of partities, als u die heeft.
• Controleer uw DML, vooral als de syntaxis correct is en de gegevens correct opslaat zoals verwacht.
• Bekijk uw opgeslagen routines, gebeurtenissen, trigger om ervoor te zorgen dat ze de verwachte resultaten uitvoeren/retourneren.
• Controleer of uw uitgevoerde query's goed werken. Ik raad u aan gebruik te maken van open-sourcetools of ons ClusterControl-product te proberen. Het biedt monitoring/waarneming, met name van uw MySQL / Percona Server. U kunt ClusterControl hier gebruiken om uw query's en het bijbehorende queryplan te controleren om er zeker van te zijn dat ze presteren.