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:
- Oracle-Nutzer zu Cloud SQL for MySQL migrieren: Terminologie und Funktionalität
- Oracle-Nutzer zu Cloud SQL for MySQL migrieren: Datentypen, Nutzer und Tabellen
- Oracle-Nutzer zu Cloud SQL for MySQL migrieren: Abfragen, gespeicherte Verfahren, Funktionen und Trigger (dieses Dokument)
- Oracle-Nutzer zu Cloud SQL for MySQL migrieren: Sicherheit, Vorgänge, Monitoring und Logging
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 derFROM
-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.
- Inline-Ansichten (auch als abgeleitete Tabellen bezeichnet) sind
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); 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 mehrSELECT
-Anweisungen an und entfernt doppelte Datensätze.UNION ALL
: hängt die Ergebnismengen von zwei oder mehrSELECT
-Anweisungen an, ohne doppelte Datensätze zu entfernen.INTERSECT
: gibt die Schnittmenge von zwei oder mehrSELECT
-Anweisungen nur dann zurück, wenn ein Datensatz in beiden Datasets vorhanden ist.MINUS
: vergleicht zwei oder mehrSELECT
-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') |
Ja | REPLACE(char,str1,str2) |
Entsprechung zu Oracle:REPLACE('ORADB', 'ORA', 'MySQL') |
TRIM(str) |
Kürzt vor- oder nachgestellte Zeichen (oder beides) aus einem String:TRIM(both '-' FROM '-MySQL-') = MySQL |
Ja | TRIM(str) |
Entsprechung zu Oracle:TRIM(both '-' FROM '-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ückREVERSE('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; |
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; |
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äßig01-AUG-19
zurück. - Die MySQL-Funktion
SYSDATE()
gibt standardmäßig2019-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); |
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; |
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) |
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 eineINSERT
-Anweisung mit folgender Ausnahme: Wenn eine alte Zeile in der Tabelle denselben Wert wie eine neue Zeile für einenPRIMARY KEY
- oderUNIQUE
-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 einemPRIMARY KEY
- oderUNIQUE
-Index verursachen würde, erfolgt einUPDATE
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; |
MySQL-Ausführungsplan |
mysql> EXPLAIN SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 105; |
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