Oracle-Nutzer zu Cloud SQL for MySQL migrieren: Abfragen, gespeicherte Verfahren, Funktionen und Trigger

Dieses Dokument ist Teil einer Reihe, die wichtige Informationen und Anleitungen im Zusammenhang mit der Planung und Durchführung von Oracle® 11g/12c-Datenbankmigrationen zu Cloud SQL for MySQL Version 5.7 (Instanzen der zweiten Generation) enthält. Die Reihe besteht aus folgenden Teilen:

Abfragen

Oracle und Cloud SQL for MySQL unterstützen den ANSI SQL-Standard. Im Allgemeinen ist die Migration von SQL-Anweisungen unkompliziert, wenn Sie nur grundlegende Syntaxelemente verwenden und beispielsweise keine Skalarfunktionen oder andere erweiterte Features von Oracle angeben. Im folgenden Abschnitt werden gängige Oracle-Abfrageelemente und die jeweiligen Entsprechungen in Cloud SQL for MySQL erläutert.

Grundlegende SELECT- und FROM-Syntax

Feature- oder Syntaxname von Oracle Überblick oder Implementierung von Oracle MySQL-Unterstützung Entsprechende oder alternative Lösung von MySQL
Grundlegende SQL-Syntax für den Datenabruf 

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY
Ja 

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY
SELECT für die Ausgabe 

SELECT 1 FROM DUAL
Ja 

SELECT 1
OR
SELECT 1 FROM DUAL
Spaltenaliasse 

SELECT COL1 AS C1
Ja 

SELECT COL1 AS C1
OR
SELECT COL1 C1
Groß-/Kleinschreibung
bei Tabellennamen		 Groß-/Kleinschreibung wird nicht berücksichtigt
(z. B. kann der Tabellenname orders und/oder ORDERS sein).		 Nein Groß-/Kleinschreibung gemäß dem definierten Tabellennamen (z. B. kann der Tabellenname nur orders oder ORDERS sein).

Weitere Informationen zur SELECT-Syntax von MySQL finden Sie hier.

  • Inline-Ansichten
    • Inline-Ansichten (auch als abgeleitete Tabellen bezeichnet) sind SELECT-Anweisungen in der FROM-Klausel, die als Unterabfrage verwendet werden.
    • Inline-Ansichten können komplexe Abfragen vereinfachen, da kumulierende Berechnungen oder Join-Vorgänge beseitigt und gleichzeitig mehrere separate Abfragen zu einer einzigen, vereinfachten Abfrage zusammengefasst werden.
    • Konvertierungshinweis: Für Inline-Ansichten von Oracle müssen keine Aliasse verwendet werden. MySQL hingegen setzt für jede Inline-Ansicht bestimmte Aliasse voraus.

Die folgende Tabelle enthält ein Konvertierungsbeispiel von Oracle zu MySQL als Inline-Ansicht.

Oracle 11g/12c 

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

Die Ausgabe sieht etwa so aus:

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
Cloud SQL for MySQL 5.7
Ohne Alias für die Inline-Ansicht:

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

Mit hinzugefügtem Alias für die Inline-Ansicht:

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

Die Ausgabe sieht etwa so aus:

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

JOIN-Anweisungen

Oracle-JOIN-Anweisungen werden von MySQL-JOIN-Anweisungen unterstützt, mit Ausnahme der FULL JOIN-Klausel. Darüber hinaus unterstützen MySQL-JOIN-Anweisungen alternative Syntax wie die USING-Klausel, die WHERE-Klausel anstelle der ON-Klausel und die Verwendung von SUBQUERY in der JOIN-Anweisung.

Die folgende Tabelle enthält ein Beispiel für eine JOIN-Konvertierung.

JOIN-Typ von Oracle Unterstützt von MySQL JOIN-Syntax von MySQL 

INNER JOIN
Ja 

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


CROSS JOIN
Ja 

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


FULL JOIN
Nein Als Behelfslösung können Sie UNION mit LEFT- und RIGHT JOIN-Anweisungen verwenden. 

LEFT JOIN
[ OUTER ]
Ja 

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


RIGHT JOIN
[ OUTER ]
Ja 

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


SUBQUERY
Ja 

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 und MINUS

MySQL unterstützt keine INTERSECT- und MINUS-Funktionen von Oracle, mit Ausnahme der UNION- und UNION ALL-Funktionen:

  • UNION: hängt die Ergebnismengen von zwei oder mehr SELECT-Anweisungen an und entfernt doppelte Datensätze.
  • UNION ALL: hängt die Ergebnismengen von zwei oder mehr SELECT-Anweisungen an, ohne doppelte Datensätze zu entfernen.
  • INTERSECT: gibt die Schnittmenge von zwei oder mehr SELECT-Anweisungen nur dann zurück, wenn ein Datensatz in beiden Datasets vorhanden ist.
  • MINUS: vergleicht zwei oder mehr SELECT-Anweisungen und gibt nur bestimmte Zeilen aus der ersten Abfrage zurück, die nicht von den anderen Anweisungen zurückgegeben werden.

Konvertierungshinweise

Wenn Sie INTERSECT- und MINUS-Funktionen von Oracle in MySQL konvertieren, sollten Sie JOIN-Anweisungen sowie IN und EXISTS als alternative Lösung verwenden.

Beispiele

Oracle-Funktion Oracle-Implementierung MySQL-Unterstützung Entsprechende oder alternative Lösung von MySQL 

UNION


SELECT COL1 FROM TBL1
UNION
SELECT COL1 FROM TBL2
Ja 

SELECT COL1 FROM TBL1
UNION
SELECT COL1 FROM TBL2


UNION ALL


SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2
Ja 

SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2


INTERSECT


SELECT COL1 FROM TBL1
INTERSECT
SELECT COL1 FROM TBL2
Nein 

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


MINUS


SELECT COL1 FROM TBL1
MINUS
SELECT COL1 FROM TBL2
Nein 

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

Skalar- (einzeilige) und Gruppenfunktionen

MySQL bietet eine umfassende Liste von Skalar- (einzeiligen) und Aggregationsfunktionen. Einige MySQL-Funktionen sind ihren Entsprechungen von Oracle recht ähnlich (nach Name und Funktionalität oder unter einem anderen Namen, aber mit ähnlicher Funktionalität). Obwohl MySQL-Funktionen identische Namen wie ihre Oracle-Entsprechungen haben können, ist ihre Funktionalität unter Umständen anders.

In der folgenden Tabelle wird beschrieben, in welchen Fällen Funktionen von Oracle und MySQL nach Name und Funktionalität vergleichbar sind (durch "Ja" gekennzeichnet) und wann eine Konvertierung empfohlen wird (alle Fälle, die nicht mit "Ja" gekennzeichnet sind).

Zeichenfunktionen
Oracle-Funktion Oracle-Funktionsspezifikation oder -Implementierung MySQL-Entsprechung Entsprechende MySQL-Funktion MySQL-Funktionsspezifikation oder -Implementierung 

CONCAT(str1,str2)
Gibt str1 zurück, verkettet mit str2:

CONCAT('A', 1) = A1
Ja 

CONCAT
Entsprechung zu Oracle:

CONCAT('A', 1) = A1


LOWER/UPPER
Gibt "char" zurück, wobei alle Buchstaben klein- oder großgeschrieben sind:

LOWER('SQL') = sql
Ja 

LOWER/UPPER
Entsprechung zu Oracle:

LOWER('SQL') = sql


LPAD/RPAD(expr1,n,expr2)
Gibt expr1 zurück, der links oder rechts auf n Zeichen mit der Reihenfolge der Zeichen in expr2 aufgefüllt ist:

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

LPAD/RPAD
Entsprechung zu Oracle:

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


SUBSTR(char,p,n)
Gibt einen Teil von char zurück, beginnend an der Zeichenposition p, wobei der Teilstring n Zeichen lang ist:

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

SUBSTR(char,p,n)
Entsprechung zu Oracle:

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


INSTR(index,str)
Gibt die Position (index) des Strings str zurück:

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

INSTR
Entsprechung zu Oracle:

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


REPLACE(char,str1,str2)
Gibt "char" zurück, wobei jeder vorkommende Suchstring durch einen Ersatzstring ersetzt wird:

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


= MySQLDB
Ja 

REPLACE(char,str1,str2)
Entsprechung zu Oracle:

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


= MySQLDB


TRIM(str)
Kürzt vor- oder nachgestellte Zeichen (oder beides) aus einem String:

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


TRIM('  MySQL ')
= MySQL
Ja 

TRIM(str)
Entsprechung zu Oracle:

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


TRIM('  MySQL ')
= MySQL


LTRIM/RTRIM(str)
Entfernt von der linken oder rechten Seite eines Strings alle Zeichen, die bei der Suche vorkommen:

LTRIM('   MySQL', ' ')
= MySQL
Teilweise 

LTRIM/RTRIM(str)
R/LTRIM-Funktion von Oracle mit Ausnahme einer Parameterersetzung (Leerzeichen oder String). R/LTRIM von MySQL entfernt nur Leerzeichen und akzeptiert nur den Eingabestring:

LTRIM('   MySQL')
= MySQL


ASCII(char)
Gibt die Dezimaldarstellung im Datenbank-Zeichensatz des ersten Zeichens von char zurück: 

ASCII('A') = 65
Ja 

ASCII(char)
Entsprechung zu Oracle:

ASCII('A') = 65


CHR(char)
Gibt den ASCII-Codewert für ein Zeichen zurück, der ein numerischer Wert zwischen 0 und 225 ist:

CHR(65) = A
Teilweise mit einem anderen Funktionsnamen 

CHAR(char)
MySQL verwendet die Funktion CHAR für dieselbe Funktionalität. Daher müssen Sie einen Funktionsnamen ändern:

CHAR(65) = A


LENGTH(str)
Gibt die Länge eines bestimmten Strings zurück:


LENGTH ('MySQL') = 5
Ja 

LENGTH(str)
Entsprechung zu Oracle:

LENGTH('MySQL') = 5


REGEXP_REPLACE(str1,expr,str2)
Sucht in einem String nach einem Muster eines regulären Ausdrucks:

REGEXP_REPLACE('John', '[hn].', '1') = Jo1
Nein – Wird nur ab MySQL Version 8 unterstützt. Verwenden Sie als Behelfslösung nach Möglichkeit die Funktion REPLACE oder konvertieren Sie die Funktionalität in die Anwendungsschicht. 

REGEXP_SUBSTR(str,expr)
Erweitert die Funktionalität der Funktion SUBSTR insofern, als in einem String nach einem Muster eines regulären Ausdrucks gesucht wird:

REGEXP_SUBSTR('https://console.cloud.google.com/sql/instances','https://([[:alnum:]]+\.?){3,4}/?')
= https://console.cloud.google.com/
Nein – Wird nur ab MySQL Version 8 unterstützt. Verwenden Sie als Behelfslösung nach Möglichkeit die Funktion SUBSTR oder konvertieren Sie die Funktionalität in die Anwendungsschicht. 

REGEXP_COUNT(str,expr)
Gibt zurück, wie häufig ein Muster in einem Quellstring vorkommt. Nein – Als alternative Lösung können Sie die Funktionalität in die Anwendungsschicht konvertieren. 

REGEXP_INSTR(index,expr)
Sucht in einer Stringposition ("index") nach einem Muster eines regulären Ausdrucks. Nein – Wird nur ab MySQL Version 8 unterstützt. 

REVERSE(str)
Gibt den umgekehrten String zurück

REVERSE('MySQL')
= LQSyM
Ja 

REVERSE
Entsprechung zu Oracle:

REVERSE('MySQL')
= LQSyM
Numerische Funktionen
Oracle-Funktion Oracle-Funktionsspezifikation oder -Implementierung MySQL-Entsprechung Entsprechende MySQL-Funktion MySQL-Funktionsspezifikation oder -Implementierung 

ABS(n)
Absoluter Wert von n: 

ABS(-4.6) = 4.6
Ja 

ABS
Entsprechung zu Oracle:

ABS(-4.6) = 4.6


CEIL(n)
Gibt die kleinste Ganzzahl zurück, die größer oder gleich n ist:

CEIL(21.4) = 22
Ja 

CEIL
Entsprechung zu Oracle:

CEIL(21.4) = 22


FLOOR(n)
Gibt die größte Ganzzahl zurück, die kleiner oder gleich n ist: 

FLOOR(-23.7) = -24
Ja 

FLOOR
Entsprechung zu Oracle:

FLOOR(-23.7) = -24


MOD(m,n)
Gibt den Rest von m geteilt durch n zurück:

MOD(10, 3) = 1
Ja 

MOD(m,n)
Entsprechung zu Oracle:

MOD(10,3) = 1


ROUND(m,n)
Gibt m zurück, gerundet auf n Ganzzahlstellen rechts vom Dezimalzeichen:

ROUND(1.39,1) = 1.4
Ja 

ROUND
Entsprechung zu Oracle:

ROUND(1.39,1) = 1.4


TRUNC(n1, n2)
 Gibt n1 zurück, gekürzt auf n2 Dezimalstellen:

TRUNC(99.999) = 99
TRUNC(99.999,0) = 99
Teilweise mit einem anderen Funktionsnamen 

TRUNCATE(n1, n2)
 Die MySQL-Funktion TRUNCATE muss eine Eingabezahl und eine Ganzzahl akzeptieren, um den Genauigkeitswert rechts vom Dezimalzeichen anzugeben:

TRUNCATE(99.999,0) = 99
Funktionen für Datum und Uhrzeit
Oracle-Funktion Oracle-Funktionsspezifikation oder -Implementierung MySQL-Entsprechung Entsprechende MySQL-Funktion MySQL-Funktionsspezifikation oder -Implementierung 

SYSDATE
Gibt das aktuelle Datum und die aktuelle Uhrzeit für das Betriebssystem zurück, auf dem sich der Datenbankserver befindet:

SELECT SYSDATE
FROM DUAL
= 31-JUL-2019
Teilweise 

SYSDATE()
SYSDATE() von MySQL muss Klammern enthalten und gibt ein anderes Datums-/Uhrzeitformat als die Oracle-Funktion SYSDATE zurück:

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

Beachten Sie, dass die Datums-/Uhrzeitformatierung auf Sitzungsebene geändert werden kann.		 

SYSTIMESTAMP
Gibt das Systemdatum zurück, einschließlich Sekundenbruchteilen und Zeitzone:

SELECT SYSTIMESTAMP FROM DUAL
= 01-JAN-19 07.37.11.622187000 AM +00:00
Teilweise mit einem anderen Funktionsnamen 

CURRENT_TIMESTAMP
MySQL gibt eine andere Datums-/Uhrzeitformatierung als Oracle zurück. Eine Datumsformatierung (oder eine andere Datumsfunktion) ist erforderlich, um der ursprünglichen Datums-/Uhrzeitformatierung zu entsprechen:

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


LOCAL_TIMESTAMP
Gibt das aktuelle Datum und die aktuelle Uhrzeit in der Zeitzone der Sitzung in einem Wert vom Datentyp TIMESTAMP zurück:

SELECT LOCAL_TIMESTAMP
FROM DUAL
= 01-JAN-19 10.01.10.123456 PM
Teilweise mit anderer Datums-/Uhrzeitformatierung 

LOCAL_TIMESTAMP
MySQL gibt eine andere Datums-/Uhrzeitformatierung als Oracle zurück. Eine Datums-/Uhrzeitformatierung (oder eine andere Datumsfunktion) ist erforderlich, um der ursprünglichen Datums-/Uhrzeitformatierung zu entsprechen:

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


CURRENT_DATE
Gibt das aktuelle Datum in der Zeitzone der Sitzung zurück:

SELECT CURRENT_DATE
FROM DUAL
= 31-JAN-19
Teilweise mit anderer Datums-/Uhrzeitformatierung 

CURRENT_DATE
MySQL gibt eine andere Datums-/Uhrzeitformatierung als Oracle zurück. Eine Datums-/Uhrzeitformatierung (oder eine andere Datumsfunktion) ist erforderlich, um der ursprünglichen Datums-/Uhrzeitformatierung zu entsprechen:

SELECT CURRENT_DATE
FROM DUAL
= 2019-01-31


CURRENT_TIMESTAMP
Gibt das aktuelle Datum und die aktuelle Uhrzeit in der Zeitzone der Sitzung zurück:

SELECT CURRENT_TIMESTAMP
FROM DUAL
= 31-JAN-19 06.54.35.543146 AM +00:00
Teilweise mit anderer Datums-/Uhrzeitformatierung 

CURRENT_TIMESTAMP
MySQL gibt eine andere Datums-/Uhrzeitformatierung als Oracle zurück. Eine Datums-/Uhrzeitformatierung (oder eine andere Datumsfunktion) ist erforderlich, um der ursprünglichen Datums-/Uhrzeitformatierung zu entsprechen:

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


ADD_MONTHS
Gibt das Datum plus ganzzahlige Monate zurück:

ADD_MONTHS(SYSDATE, 1)
= 31-JAN-19
Teilweise mit einem anderen Funktionsnamen 

ADDDATE
MySQL verwendet die Funktion ADDDATE, um dieselbe Funktionalität zu erreichen:

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

MySQL gibt standardmäßig ein anderes Datum/eine andere Uhrzeit und einen anderen Bereich/ein anderes Format als Oracle zurück. Eine Datums-/Uhrzeitformatierung (oder eine andere Datumsfunktion) ist erforderlich, um der ursprünglichen Datums-/Uhrzeitformatierung zu entsprechen:
EXTRACT(Datumsteil) Gibt den Wert eines angegebenen Datums-/Uhrzeitfelds aus einem Datums-/Uhrzeit- oder Intervallausdruck zurück:

EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019
Ja EXTRACT (Datumsteil) Entsprechung zu Oracle:

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


LAST_DAY
Gibt das Datum des letzten Tages des Monats zurück:

LAST_DAY('01-JAN-2019')
= 31-JAN-19
Teilweise mit anderer Datums-/Uhrzeitformatierung 

LAST_DAY
MySQL gibt eine andere Datums-/Uhrzeitformatierung als Oracle zurück. Eine Datums-/Uhrzeitformatierung (oder eine andere Datumsfunktion) ist erforderlich, um der ursprünglichen Datums-/Uhrzeitformatierung zu entsprechen:

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


MONTH_BETWEEN
Gibt die Anzahl der Monate zwischen den Datumsangaben "date1" und "date2" zurück:

MONTHS_BETWEEN(
SYSDATE, SYSDATE-60)
= 1.96
Teilweise mit einem anderen Funktionsnamen 

PERIOD_DIFF(date1,date2)
Die MySQL-Funktion PERIOD_DIFF gibt die Differenz in Monaten als Ganzzahl zwischen zwei Zeiträumen zurück (im Format YYMM oder YYYYMM):

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

Wenn Sie dieselben Werte wie die Oracle-Funktion MONTH_BETWEEN erreichen möchten, ist eine spezifischere Konvertierung erforderlich.
TO_CHAR (Datum/Uhrzeit) Wandelt einen Datums-/Uhrzeit- oder Zeitstempeldatentyp in einen Wert des Datentyps VARCHAR2 in dem durch das Datumsformat angegebenen Format um:

TO_CHAR(
SYSDATE,'DD-MM-YYYY HH24:MI:SS')
= 01-01-2019 10:01:01
Teilweise mit einem anderen Funktionsnamen 

DATE_FORMAT
Die MySQL-Funktion DATE_FORMAT formatiert ein Datum wie durch eine Datumsformatdefinition angegeben:

DATE_FORMAT(
SYSDATE(),'%d-%m-%Y %H:%i:%s')
= 01-01-2019 10:01:01
Codierungs- und Decodierungsfunktionen
Oracle-Funktion Oracle-Funktionsspezifikation oder -Implementierung MySQL-Entsprechung Entsprechende MySQL-Funktion MySQL-Funktionsspezifikation oder -Implementierung 

DECODE
Vergleicht den Ausdruck anhand der Funktionalität einer IF-THEN-ELSE-Anweisung einzeln mit jedem Suchwert. Nein 

CASE
Verwenden Sie die MySQL-Anweisung CASE, um eine ähnliche Funktionalität zu erreichen. 

DUMP
Gibt einen VARCHAR2-Wert zurück, der den Datentypcode, die Länge in Byte und die interne Darstellung eines bestimmten Ausdrucks enthält. Nein – Nicht unterstützt. 

ORA_HASH
Berechnet einen Hashwert für einen bestimmten Ausdruck. Nein 

MD5/SHA
Verwenden Sie MD5 von MySQL für 128-Bit-Prüfsummen oder die Funktion SHA für 160-Bit-Prüfsummen, um Hashwerte zu generieren.
Konvertierungsfunktionen
Oracle-Funktion Oracle-Funktionsspezifikation oder -Implementierung MySQL-Entsprechung Entsprechende MySQL-Funktion MySQL-Funktionsspezifikation oder -Implementierung 

CAST
Konvertiert einen integrierten Datentyp oder Sammlungstypwert in einen anderen integrierten Datentyp oder Sammlungstypwert:

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

CAST
Die MySQL-Funktion CAST ist der Oracle-Funktionalität ähnlich, muss aber in bestimmten Fällen angepasst werden, je nachdem, ob eine explizite oder implizite Konvertierung erforderlich ist:

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


CONVERT
Konvertiert einen Zeichenstring von einem Zeichensatz in einen anderen:

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

CONVERT
Die MySQL-Funktion CONVERT erfordert einige Anpassungen der Syntax und der Parameter, um die gleichen Ergebnisse wie Oracle zurückzugeben:

CONVERT('Ä Ê Í A B C ' USING utf8)
= Ä Ê Í A B C
TO_CHAR
(String/Zahl)		 Die Funktion konvertiert eine Zahl oder ein Datum in einen String: 

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

FORMAT
Die MySQL-Funktion FORMAT konvertiert eine Zahl in das Format "#,###.##", rundet sie auf eine bestimmte Anzahl von Dezimalstellen und gibt dann das Ergebnis als String zurück. Sie hat eine andere Funktionalität als Oracle:

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


TO_DATE
Die Oracle-Funktion TO_DATE konvertiert einen String in ein Datum gemäß dem quellspezifischen Datums-/Uhrzeitformat:

TO_DATE(
'2019/01/01', 'yyyy-mm-dd')
= 01-JAN-2019
Teilweise mit einem anderen Funktionsnamen und einer anderen Datums-/Uhrzeitformatierung 

STR_TO_DATE
Die MySQL-Funktion STR_TO_DATE nimmt einen String an und gibt ein Datum zurück, das durch eine Datums-/Uhrzeitformatierung angegeben ist:

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


TO_NUMBER
Konvertiert den Ausdruck in einen Wert des Datentyps NUMBER:

TO_NUMBER('01234')
= 1234
Nein 

CAST
Alternativ können Sie mit der MySQL-Funktion CAST dasselbe Ergebnis wie die Oracle-Funktion TO_NUMBER zurückgeben:

CAST('01234' as SIGNED)
= 1234
Bedingte SELECT-Funktionen
Oracle-Funktion Oracle-Funktionsspezifikation oder -Implementierung MySQL-Entsprechung Entsprechende MySQL-Funktion MySQL-Funktionsspezifikation oder -Implementierung 

CASE
Bei der Anweisung CASE wird aus einer Reihe von Bedingungen eine Auswahl getroffen und eine entsprechende Anweisung mit der folgenden Syntax ausgeführt:

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

CASE
Zusätzlich zur Funktion CASE unterstützt MySQL die Verwendung der bedingten IF/ELSE-Verarbeitung in der Anweisung SELECT:

CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END
Nullfunktionen
Oracle-Funktion Oracle-Funktionsspezifikation oder -Implementierung MySQL-Entsprechung Entsprechende MySQL-Funktion MySQL-Funktionsspezifikation oder -Implementierung 

COALESCE
Gibt den ersten Nicht-Nullausdruck in der Ausdrucksliste zurück: 

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

COALESCE
Entsprechung zu Oracle:

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


NULLIF
Vergleicht "expr1" und "expr2m". Wenn die Werte gleich sind, gibt die Funktion null zurück. Wenn sie nicht gleich sind, gibt die Funktion "expr1" zurück: 

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

NULLIF
Entsprechung zu Oracle:

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


NVL
Ersetzt null (als Leerzeichen zurückgegeben) durch einen String in den Ergebnissen einer Abfrage:

NVL(null, 'a')
= a
Nein 

IFNULL
Die entsprechende MySQL-Funktion wäre die Funktion IFNULL , die Nullwerte durch einen bestimmten String ersetzt:

IFNULL(null, 'a')
= a


NVL2
Bestimmt den von einer Abfrage zurückgegebenen Wert anhand der Tatsache,
ob ein angegebener Ausdruck null ist oder nicht.		 Nein 

CASE
Bei der CASE-Anweisung
wird aus einer Reihe von Bedingungen eine Auswahl getroffen und eine entsprechende Anweisung ausgeführt:

CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END
Umgebungs- und Kennungsfunktionen
Oracle-Funktion Oracle-Funktionsspezifikation oder -Implementierung MySQL-Entsprechung Entsprechende MySQL-Funktion MySQL-Funktionsspezifikation oder -Implementierung 

SYS_GUID
Generiert eine global eindeutige Kennung (RAW-Wert), die aus 16 Byte besteht, und gibt diese zurück:

SELECT SYS_GUID()
FROM DUAL
= 8EFA4A31468B4C6DE05011AC0200009E
Nein REPLACE und UUID Verwenden Sie als Behelfslösung die MySQL-Funktionen REPLACE und UUID, um die Oracle-Funktion SYS_GUID zu simulieren:

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


UID
Gibt eine Ganzzahl zurück, mit der der Sitzungsnutzer (der angemeldete Nutzer)
zweifelsfrei identifiziert werden kann:

SELECT UID FROM DUAL
= 43
Nein – – 

USER
Gibt den Namen des aktuellen Sitzungsnutzers zurück:

SELECT USER FROM DUAL
= UserName
Teilweise 

USER + INSTR + SUBSTR
Die MySQL-Funktion USER gibt den Nutzernamen zusammen mit dem Verbindungsserver (root@IP) zurück. Wenn Sie nur den Nutzernamen abrufen möchten, verwenden Sie die zusätzlichen unterstützenden Funktionen:

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


USERENV
Gibt Informationen zur aktuellen Nutzersitzung mit der aktuellen Parameterkonfiguration zurück:

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

SHOW SESSION
VARIABLES
Verwenden Sie die MySQL-Anweisung SHOW SESSION
VARIABLES, um die Einstellungen für die aktuelle Sitzung abzurufen:

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


ROWID
Der Oracle-Server weist jeder Zeile in jeder Tabelle eine eindeutige ROWID zu, damit die Zeile in der Tabelle identifiziert werden kann. Die ROWID ist die Adresse der Zeile, die die Datenobjektnummer, den Datenblock der Zeile, die Zeilenposition und die Datendatei enthält. Nein – Versuchen Sie nach Möglichkeit, dieselbe Funktionalität mit anderen MySQL-Funktionen zu emulieren. 

ROWNUM
Gibt eine Zahl zurück, die die Reihenfolge darstellt, in der Oracle eine Zeile aus einer Tabelle oder verknüpften Tabellen auswählt. Nein – Versuchen Sie nach Möglichkeit, dieselbe Funktionalität mit anderen MySQL-Funktionen oder -Sitzungsvariablen zu emulieren.
Aggregatfunktionen (Gruppenfunktionen)
Oracle-Funktion Oracle-Funktionsspezifikation oder
-Implementierung		 MySQL-
Entsprechung		 Entsprechende MySQL-Funktion MySQL-Funktionsspezifikation oder -Implementierung 

AVG
Gibt den Durchschnittswert einer Spalte oder eines Ausdrucks zurück. Ja 

AVG
Entsprechung zu Oracle 

COUNT
Gibt die Anzahl der von einer Abfrage zurückgegebenen Zeilen zurück. Ja 

COUNT
Entsprechung zu Oracle 

COUNT
(DISTINCT)
Gibt die Anzahl der eindeutigen Werte in der Spalte oder im Ausdruck zurück. Ja 

COUNT
(DISTINCT)
Entsprechung zu Oracle 

MAX
Gibt den Höchstwert einer Spalte oder eines Ausdrucks zurück. Ja 

MAX
Entsprechung zu Oracle 

MIN
Gibt den Mindestwert einer Spalte oder eines Ausdrucks zurück. Ja 

MIN
Entsprechung zu Oracle 

SUM
Gibt die Summe des Werts einer Spalte oder eines Ausdrucks zurück. Ja 

SUM
Entsprechung zu Oracle 

LISTAGG
Zeigt die Daten in jeder Gruppe anhand einer einzelnen Zeile, die in der ORDER BY-Klausel angegeben ist, durch Verkettung der Werte der Messwertspalte an:

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


-- Single line results


= Accounting, Administration, Benefits, Construction
Nein 

GROUP_CONCAT
Verwenden Sie die MySQL-Funktion GROUP_CONCAT, um ähnliche Ergebnisse wie Oracle zurückzugeben. Gehen Sie in bestimmten Fällen von Syntaxunterschieden aus:

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


-- Single line results


= Accounting, Administration, Benefits, Construction
Fetch von Oracle 12c
Oracle-Funktion Oracle-Funktionsspezifikation oder
-Implementierung		 MySQL-
Entsprechung		 Entsprechende MySQL-Funktion MySQL-Funktionsspezifikation oder -Implementierung 

FETCH
Ruft Datenzeilen aus der Ergebnismenge einer mehrzeiligen Abfrage ab: 

SELECT * FROM
EMPLOYEES
FETCH FIRST 10 ROWS ONLY;
Nein LIMIT Verwenden Sie die MySQL-Klausel LIMIT, um nur eine bestimmte Gruppe von Datensätzen abzurufen:

SELECT * FROM
EMPLOYEES
LIMIT 10;

Grundlegende Filter, Operatoren und Unterabfragen

Während der Konvertierung sind grundlegende Filter, Operatorfunktionen und Unterabfragen relativ unkompliziert und erfordern minimalen bis keinen zusätzlichen Aufwand.

Konvertierungshinweise

Sehen Sie sich Datumsformate genau an und behandeln Sie sie entsprechend, da Oracle- und MySQL-Formate unterschiedliche Standardergebnisse zurückgeben:

  • Die Oracle-Funktion SYSDATE gibt standardmäßig 01-AUG-19 zurück.
  • Die MySQL-Funktion SYSDATE() gibt standardmäßig 2019-08-01 12:04:05 zurück.
  • Datums- und Uhrzeitformate können mit den MySQL-Funktionen [DATE_FORMAT](https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_date-format) oder [STR_TO_DATE](https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_str-to-date) festgelegt werden.
Oracle-Funktion oder -Unterabfrage MySQL-Entsprechung Entsprechende MySQL-Funktion oder -Unterabfrage MySQL-Funktionsspezifikation oder -Implementierung 

EXISTS/NOT EXISTS
Ja 

EXISTS/NOT EXISTS


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


IN/NOT IN
Ja 

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
Ja 

LIKE/NOT LIKE


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


BETWEEN/NOT BETWEEN
Ja 

BETWEEN/NOT BETWEEN


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


AND/OR
Ja 

AND/OR


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


SubQuery
Ja 

SubQuery
MySQL unterstützt Unterabfragen auf SELECT-Ebene für JOIN-Anweisungen und zum Filtern in den WHERE/AND-Klauseln:

-- 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);
Operatoren Ja Operatoren MySQL unterstützt alle grundlegenden Operatoren:

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

Analysefunktionen (oder Fenster- und Rankingfunktionen)

Oracle-Analysefunktionen erweitern die Funktionalität von Standard-SQL-Analysefunktionen insofern, als sie die Möglichkeit bieten, aggregierte Werte auf Basis einer Gruppe von Zeilen zu berechnen. Diese Funktionen können auf logisch partitionierte Ergebnismengen innerhalb eines einzelnen Abfrageausdrucks angewendet werden. Sie werden meist in Verbindung mit Business Intelligence-Berichten und -Analysen verwendet, um die Abfrageleistung potenziell zu verbessern, ohne für dasselbe Ergebnis komplexeren, nicht analytischen SQL-Code verwenden zu müssen.

Konvertierungshinweise

  • MySQL Version 5.7 bietet keine Analysefunktionen, um eine einfache Konvertierung von SQL-Anweisungen zu unterstützen. Da diese Funktionalität jedoch teilweise in MySQL Version 8 hinzugefügt wurde, stellt die Konvertierung analytischer Funktionen einen wichtigen Punkt dar, der berücksichtigt werden sollte und wahrscheinlich einen manuellen Aufwand im Migrationsprozess nach sich zieht.
  • Optional können Sie Analysefunktionen durch Umschreiben von Code entfernen, auf traditionellere SQL-Codelösungen zurückgreifen oder diese Logik in eine Anwendungsschicht verschieben.

In der folgenden Tabelle sind die gängigen Analysefunktionen von Oracle aufgeführt.

Funktionsfamilie Ähnliche Funktionen Unterstützt von MySQL 5.7
Analyse und Ranking 

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

CONNECT BY
HIER_ANCESTOR
HIER_CHILD_COUNT
HIER_DEPTH
HIER_LEVEL
HIER_ORDER
HIER_PARENT
HIER_TOP
Nein
Verzögerung 

LAG
LAG_VARIANCE LAG_VARIANCE_PERCENT LEAD
LEAD_VARIANCE LEAD_VARIANCE_PERCENT
Nein

Allgemeiner Tabellenausdruck (Common Table Expression, CTE)

Mithilfe von CTEs können Sie die Logik von sequenziellem Code implementieren, um SQL-Code wiederzuverwenden, der für die mehrfache Verwendung zu komplex oder nicht effizient ist. CTEs können benannt und dann in verschiedenen Teilen einer SQL-Anweisung mithilfe der Klausel WITH mehrfach verwendet werden.

Konvertierungshinweise

  • Im Gegensatz zu MySQL Version 8 unterstützt MySQL Version 5.7 keine CTEs.
  • Verwenden Sie als alternative Lösung abgeleitete Tabellen bzw. Unterabfragen oder schreiben Sie die SQL-Anweisung so um, dass die CTE-Funktionalität entfernt wird.

Beispiele

Oracle 

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

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;

MERGE-Anweisung

Die Anweisung MERGE (oder UPSERT) bietet die Möglichkeit, einzelne SQL-Anweisungen anzugeben, die DML-Vorgänge in einem einzigen MERGE-Vorgang bedingt ausführen, im Gegensatz zu einem einzelnen DML-Vorgang, der separat ausgeführt wird. Die Anweisung wählt Datensätze aus der Quelltabelle aus und führt dann durch Angabe einer logischen Struktur automatisch mehrere DML-Vorgänge für die Zieltabelle aus. Mit diesem Feature vermeiden Sie die Verwendung mehrerer Insert-. Update- oder Delete-Vorgänge. Beachten Sie, dass MERGE eine deterministische Anweisung ist. Das bedeutet, dass eine Zeile, die von der MERGE-Anweisung verarbeitet wurde, nicht noch einmal mit derselben MERGE-Anweisung verarbeitet werden kann.

Konvertierungshinweise

Im Gegensatz zu Oracle wird die MERGE-Funktionalität von MySQL Version 5.7 nicht unterstützt. Zur teilweisen Simulation der MERGE-Funktionalität stellt MySQL die Anweisungen REPLACE und INSERT… ON DUPLICATE KEY UPDATE bereit:

  • REPLACE: Funktioniert wie eine INSERT-Anweisung mit folgender Ausnahme: Wenn eine alte Zeile in der Tabelle denselben Wert wie eine neue Zeile für einen PRIMARY KEY- oder UNIQUE-Index hat, wird die alte Zeile gelöscht, bevor die neue Zeile eingefügt wird.

  • INSERT… ON DUPLICATE KEY UPDATE: Wenn eine eingefügte Zeile einen doppelten Wert in einem PRIMARY KEY- oder UNIQUE-Index verursachen würde, erfolgt ein UPDATE der alten Zeile, um eine doppelte Schlüsselausnahme zu vermeiden. Beispiel:

    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;

Eine weitere Lösung besteht darin, die MERGE-Funktionalität in eine gespeicherte Prozedur zu konvertieren, um DML-Vorgänge mithilfe der Befehle INSERT, UPDATE und DELETE zu verwalten. Dabei werden Ausnahmen und Duplikate behandelt.

Hinweise für SQL-Anweisungen

Oracle bietet eine große Sammlung von SQL-Abfragehinweisen, mit denen Nutzer das Verhalten des Optimierungstools und dessen Entscheidungen beeinflussen können, um effizientere Abfrageausführungspläne zu erstellen. Oracle unterstützt über 60 verschiedene Datenbankhinweise. MySQL bietet einen begrenzten Satz von Abfragehinweisen.

Im Allgemeinen unterstützt MySQL Version 5.7 zwei Arten von Abfragehinweisen: OPTIMIZER HINTS und INDEX HINTS. Mit den MySQL-Optimierungshinweisen lässt sich das Verhalten des Optimierungstools in einzelnen SQL-Anweisungen steuern. Beispiel:

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

Verfügbare Optimierungshinweise in MySQL Version 5.7

Hinweisname Hinweisübersicht Gültige Bereiche 

BKA, NO_BKA
Wirkt sich auf die Verarbeitung von Batch-Schlüsselzugriff-Joins aus Abfrageblock, Tabelle 

BNL, NO_BNL
Wirkt sich auf die Verarbeitung von blockverschachtelten Schleifen-Joins aus Abfrageblock, Tabelle 

MAX_EXECUTION_TIME
Beschränkt die Ausführungszeit von Anweisungen Global 

MRR, NO_MRR
Wirkt sich auf die Optimierung von Lesevorgängen in mehreren Bereichen aus Tabelle, Index 

NO_ICP
Wirkt sich auf Optimierung des Indexbedingungs-Push-downs aus Tabelle, Index 

NO_RANGE_OPTIMIZATION
Wirkt sich auf die Bereichsoptimierung aus Tabelle, Index 

QB_NAME
Weist dem Abfrageblock einen Namen zu Abfrageblock 

SEMIJOIN, NO_SEMIJOIN
Wirkt sich auf Semi-Join-Strategien aus Abfrageblock 

SUBQUERY
Wirkt sich auf Materialisierungs-, IN-zu-EXISTS-Unterabfragen-Strategien aus Abfrageblock

MySQL-Indexhinweise stellen dem Optimierungstool Informationen zur Auswahl von Indexen während der Abfrageverarbeitung bereit. Die Keywords USE, FORCE oder IGNORE werden verwendet, um die Indexverwendung des Optimierungstools zu steuern. Beispiel:

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

Konvertierungshinweise

Da es grundlegende Unterschiede zwischen dem Oracle- und MySQL-Optimierungstool gibt und sich die Oracle- und MySQL-Abfragehinweise so gut wie gar nicht überschneiden, empfehlen wir, dass Sie jede Oracle-SQL-Anweisung mit nicht spezifizierten Abfragehinweise zur MySQL-Zieldatenbank konvertieren.

Verwenden Sie für die MySQL-Leistungsoptimierung MySQL-Tools (z. B. MySQL Workbench für Echtzeit-Dashboards zur Leistungsüberwachung) und Features wie das Untersuchen von Abfragen mithilfe von Ausführungsplänen und das Anpassen der Instanz- oder Sitzungsparameter gemäß Anwendungsfall.

Ausführungspläne

Der Hauptzweck von Ausführungsplänen besteht darin, einen Einblick in die Entscheidungen zu geben, die vom Abfrageoptimierungstool für den Zugriff auf Datenbankdaten getroffen wurden. Das Abfrageoptimierungstool generiert Ausführungspläne für SELECT-, INSERT-, UPDATE- und DELETE-Anweisungen für Datenbanknutzer und verschafft Administratoren außerdem einen besseren Überblick über bestimmte Abfragen und DML-Vorgänge. Ausführungspläne sind besonders nützlich, wenn Sie die Leistung von Abfragen optimieren müssen. Sie können damit beispielsweise die Indexleistung ermitteln oder feststellen, ob Indexe fehlen, die erstellt werden müssen.

Ausführungspläne können von Datenvolumen, Datenstatistiken und Instanzparametern (globale oder Sitzungsparameter) beeinflusst werden.

Überlegungen zu Konvertierungen

Ausführungspläne sind keine Datenbankobjekte, die migriert werden müssen. Sie sind vielmehr ein Tool zum Analysieren von Leistungsunterschieden zwischen Oracle und MySQL, wenn dieselbe Anweisung für identische Datasets ausgeführt wird.

MySQL unterstützt nicht die gleiche Ausführungsplansyntax, -funktionalität oder -ausgabe wie Oracle.

Beispiele

Oracle-Ausführungsplan 

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-Ausführungsplan 

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

Gespeicherte Verfahren, Funktionen und Trigger

PL/SQL ist die erweiterte prozedurale Programmiersprache von Oracle, mit der codebasierte Lösungen in der Datenbank erstellt, gespeichert und angewendet werden. Im Allgemeinen handelt es sich bei in Datenbanken gespeicherten Verfahren und Funktionen um Codeelemente, die aus ANSI SQL und der erweiterten prozeduralen SQL-Programmiersprache bestehen, z. B. PL/SQL für Oracle, PL/pgSQL für PostgreSQL und die prozedurale Programmiersprache MySQL für MySQL. MySQL verwendet für seine eigene erweiterte prozedurale Programmiersprache denselben Namen wie für die Datenbank.

Der Zweck dieser gespeicherten Verfahren und Funktionen besteht darin, Lösungen für Anforderungen wie Leistung, Kompatibilität und Sicherheit bereitzustellen, die sich besser in der Datenbank als in der Anwendung ausführen lassen. Obwohl PL/SQL sowohl in gespeicherten Verfahren als auch Funktionen zum Einsatz kommt, werden gespeicherte Verfahren hauptsächlich zum Ausführen von DDL/DML-Vorgängen verwendet und Funktionen hauptsächlich zum Ausführen von Berechnungen, um bestimmte Ergebnisse zurückzugeben.

Von der prozeduralen Programmiersprache PL/SQL zu MySQL

Im Hinblick auf eine Codemigration von Oracle PL/SQL zu MySQL zeigen sich Unterschiede zwischen den prozeduralen Implementierungen von MySQL und Oracle auf. Die Codemigration ist daher notwendig, um die PL/SQL-Funktionalität von Oracle in gespeicherte Verfahren und Funktionen von MySQL zu konvertieren. Darüber hinaus werden Oracle-Pakete und -Pakettexte von MySQL nicht unterstützt. Wenn Sie also eine Codekonvertierung ausführen, müssen Sie diese Elemente in einzelne MySQL-Codeeinheiten konvertieren (oder in diese parsen). Beachten Sie, dass gespeicherte Verfahren und Funktionen von MySQL auch als Routinen bezeichnet werden.

Codeobjektinhaber

In Oracle ist der Inhaber einer gespeicherten Prozedur oder Funktion ein bestimmter Nutzer. In MySQL ist der Inhaber ein bestimmtes Schema, das von einem Datenbanknutzer in einer Datenbank erstellt wurde.

Berechtigungen und Sicherheit für Codeobjekte

In Oracle benötigt der Nutzer die Systemberechtigung CREATE PROCEDURE, um gespeicherte Verfahren oder Funktionen zu erstellen. Damit Datenbanknutzer im Namen von anderen Nutzern Verfahren oder Funktionen erstellen können, benötigen sie die Berechtigung CREATE ANY PROCEDURE. Zum Ausführen einer gespeicherten Prozedur oder Funktion müssen die Datenbanknutzer die Berechtigung EXECUTE haben.

In MySQL benötigt der Nutzer die Berechtigung CREATE ROUTINE, um ein Codeelement zu erstellen, und die Berechtigung EXECUTE, um dieses auszuführen. Die MySQL-Klausel DEFINER definiert den Nutzerersteller für das Codeobjekt und der Nutzer muss die entsprechenden Berechtigungen wie CREATE ROUTINE haben.

Gespeicherte Verfahren und Funktionssyntax für MySQL

Das folgende Beispiel zeigt die Syntax von gespeicherten Verfahren und Funktionen von MySQL:

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