Abfragen von Oracle Database nach Cloud SQL for MySQL konvertieren und optimieren

In diesem Dokument werden die grundlegenden Unterschiede zwischen Oracle® und Cloud SQL for MySQL bei Abfragen vorgestellt und es wird beschrieben, wie Features in Oracle den Features in Cloud SQL for MySQL zugeordnet werden. Außerdem werden Leistungsaspekte für Cloud SQL for MySQL und Möglichkeiten zur Analyse und Optimierung der Abfrageleistung in Google Cloud präsentiert. In diesem Dokument geht es zwar um Techniken zur Optimierung gespeicherter Verfahren und Trigger für Cloud SQL for MySQL, aber nicht um die Übersetzung von PL/SQL-Code in gespeicherte MySQL-Verfahren und -Funktionen.

Beim Konvertieren von Abfragen von Oracle Database nach Cloud SQL for MySQL sind Unterschiede zwischen bestimmten SQL-Dialekten zu beachten. Außerdem gibt es mehrere eingebundene Funktionen, die auf den beiden Datenbankplattformen unterschiedlich oder nicht kompatibel sind.

Grundlegende Unterschiede bei Abfragen

Obwohl Oracle und Cloud SQL for MySQL ANSI SQL unterstützen, gibt es einige grundlegende Unterschiede bei der Datenabfrage, hauptsächlich in Bezug auf die Verwendung von Systemfunktionen.

In der folgenden Tabelle sind die Unterschiede in der SELECT- und FROM-Syntax für Oracle und Cloud SQL for MySQL aufgeführt.

Name des Oracle-Features	Umsetzung in Oracle	Cloud SQL for MySQL-Unterstützung	Cloud SQL for MySQL-Entsprechung
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 oder SELECT 1 FROM DUAL
Spalten-Aliasse	SELECT COL1 AS C1	Ja	SELECT COL1 AS C1 oder SELECT COL1 C1
Groß-/Kleinschreibung bei Tabellennamen	Groß-/Kleinschreibung wird nicht berücksichtigt (z. B. kann der Tabellenname orders und ORDERS sein).	Nein	Groß-/Kleinschreibung gemäß dem definierten Tabellennamen (z. B. kann der Tabellenname nur orders oder ORDERS sein).

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 dazu beitragen, komplexe Abfragen zu vereinfachen, indem kumulierende Berechnungen oder Join-Vorgänge beseitigt werden. Gleichzeitig werden mehrere separate Abfragen zu einer einzigen, vereinfachten Abfrage zusammengefasst.

Hinweis: Für Inline-Ansichten von Oracle müssen keine Aliasse verwendet werden. Cloud SQL for MySQL hingegen erfordert für jede Inline-Ansicht einen eigenen Alias.

Im folgenden Beispiel wird eine Konvertierung von Oracle 11g/12c nach Cloud SQL for MySQL für eine Inline-Ansicht veranschaulicht.

Eine Inline-Ansicht in Oracle 11g/12c:

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

Eine Arbeitsansicht in Cloud SQL for MySQL 5.7 mit einem Alias:

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

Joins

Mit Ausnahme von FULL JOIN werden die Join-Typen von Oracle von Cloud SQL for MySQL unterstützt. Cloud SQL for MySQL-Joins unterstützen die Verwendung einer alternativen Syntax wie die USING-Klausel, die WHERE-Klausel anstelle der ON-Klausel und die SUBQUERY in der JOIN-Anweisung.

Die folgende Tabelle zeigt ein Beispiel für eine JOIN-Konvertierung.

JOIN-Typ von Oracle	Cloud SQL for MySQL-Unterstützung	JOIN-Syntax von Cloud SQL for 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	Erwägen Sie die Verwendung von UNION mit LEFT und RIGHT JOINS: SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E LEFT JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID UNION SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E RIGHT JOIN DEPARTMENTS D ON E.DEPARTMENT_ID = D.DEPARTMENT_ID; .
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;

Cloud SQL for MySQL unterstützt die Funktionen UNION und UNION ALL, die Funktionen INTERSECT und MINUS werden von Oracle jedoch nicht unterstützt:

• Mit UNION werden die Ergebnismengen von zwei SELECT-Anweisungen angehängt, nachdem doppelte Datensätze entfernt wurden.
• Mit UNION ALL werden die Ergebnismengen von zwei SELECT-Anweisungen angehängt, ohne doppelte Datensätze zu entfernen.
• INTERSECT gibt die Schnittmenge von zwei SELECT-Anweisungen zurück, wenn in den Ergebnismengen aus beiden Abfragen ein Datensatz vorhanden ist.
• Mit MINUS werden zwei oder mehr SELECT-Anweisungen miteinander verglichen und nur bestimmte Zeilen aus der ersten Abfrage zurückgegeben, die von der zweiten Abfrage nicht zurückgegeben werden.

Hinweis: Verwenden Sie die Funktion JOIN, IN, oder EXISTS bei der Konvertierung von INTERSECT oder MINUS von Oracle nach Cloud SQL for MySQL als Behelfslösung.

Die folgende Tabelle enthält einige Beispiele für die Konvertierung von Oracle nach Cloud SQL for MySQL.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Unterstützung	Cloud SQL for MySQL-Entsprechung
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

Skalierungs- und Gruppenfunktionen

Cloud SQL for MySQL bietet eine umfassende Liste von (einzeiligen) Skalierungs- und Aggregationsfunktionen. Einige Funktionen von Cloud SQL for MySQL sind ihren Entsprechungen von Oracle recht ähnlich (nach Name und Funktionalität oder unter einem anderen Namen, aber mit ähnlicher Funktionalität). Obwohl einige Funktionen von Cloud SQL for MySQL identische Namen wie ihre Entsprechungen von Oracle haben, können sie auch über andere Funktionalitäten verfügen.

In der folgenden Tabelle wird beschrieben, in welchen Fällen Zeichenfunktionen von Oracle und Cloud SQL for MySQL nach Name und Funktionalität vergleichbar sind und wann eine Konvertierung empfohlen wird.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Entsprechung	Cloud SQL for MySQL-Funktion	Umsetzung in Cloud SQL for MySQL
CONCAT	Gibt den ersten String zurück, der mit dem zweiten String verkettet ist: CONCAT('A', 1) = A1	Ja	CONCAT	CONCAT('A', 1) = A1
CONCAT USING PIPE	FNAME |' '| LNAME	Nein	CONCAT	CONCAT(FNAME, ' ', LNAME)
LOWER oder UPPER	Gibt den String mit allen Klein- oder Großbuchstaben zurück: LOWER('SQL') = sql	Ja	LOWER oder UPPER	LOWER('SQL') = sql
LPAD/RPAD	Gibt expression1 zurück, links oder rechts auf n Zeichen aufgefüllt, mit der Zeichenfolge in expression2: LPAD('A',3,'*') = **A	Ja	LPAD oder RPAD	LPAD('A',3,'*') = **A
SUBSTR	Gibt einen Teil des Strings ab Position x (in diesem Fall 3) mit einer Länge von y zurück. Die erste Position im String ist 1. SUBSTR('MySQL', 3, 3) = SQL	Ja	SUBSTR	SUBSTR('MySQL', 3, 3) = SQL
INSTR	Gibt die Position (Index) eines Strings aus einem bestimmten String zurück: INSTR('MySQL', 'y') = 2	Ja	INSTR	INSTR('MySQL', 'y') = 2
REPLACE	Gibt einen String zurück, bei dem jeder vorkommende Suchstring durch einen Ersatzstring ersetzt wird: REPLACE('ORADB', 'ORA', 'MySQL') = MySQLDB	Ja	REPLACE	REPLACE('ORADB', 'ORA', 'MySQL') = MySQLDB
TRIM	Kürzt vor- oder nachgestellte Zeichen (oder beides) aus einem String: TRIM(both '-' FROM '-MySQL-') = MySQL TRIM(' MySQL ') = MySQL	Ja	TRIM	TRIM(both '-' FROM '-MySQL-') = MySQL TRIM(' MySQL ') = MySQL
LTRIM/RTRIM	Entfernt von der linken oder rechten Seite eines Strings alle Zeichen, die bei der Suche vorkommen: LTRIM(' MySQL', ' ') = MySQL	Teilweise	LTRIM or RTRIM	Die Funktionen LTRIM und RTRIM von Oracle haben einen zweiten Parameter, mit dem angegeben wird, welche vorangestellten oder nachgestellten Zeichen aus dem String entfernt werden sollen. Bei Cloud SQL for MySQL-Funktionen werden nur vorangestellte und nachgestellte Leerzeichen aus dem angegebenen String entfernt: LTRIM(' MySQL') = MySQL
ASCII	Nimmt ein einzelnes Zeichen und gibt den numerischen ASCII-Code zurück: ASCII('A') = 65	Ja	ASCII	ASCII('A') = 65
CHR	Gibt den ASCII-Codewert für ein Zeichen zurück, bei dem es sich um einen numerischen Wert zwischen 0 und 225 handelt: CHR(65) = A	Erfordert einen anderen Funktionsnamen.	CHAR	Cloud SQL for MySQL verwendet für dieselbe Funktionalität die Funktion CHAR. Daher müssen Sie den Funktionsnamen ändern: CHAR(65) = A
LENGTH	Gibt die Länge eines bestimmten Strings zurück: LENGTH('MySQL') = 5	Ja	LENGTH	LENGTH('MySQL') = 5
REGEXP_REPLACE	Sucht in einem String nach einem Muster eines regulären Ausdrucks: REGEXP_REPLACE('John', '[hn].', 'e') = Joe	Nein	–	Wird ab MySQL-Version 8 unterstützt. Verwenden Sie als Behelfslösung nach Möglichkeit die Funktion REPLACE oder verschieben Sie die Logik in die Anwendungsebene.
REGEXP_SUBSTR	Erweitert die Funktionalität der Funktion SUBSTR, indem 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 ab MySQL-Version 8 unterstützt. Verwenden Sie als Behelfslösung nach Möglichkeit die Funktion SUBSTR oder verschieben Sie die Logik in die Anwendungsebene.
REGEXP_COUNT	Gibt zurück, wie häufig ein Muster in einem Quellstring vorkommt.	Nein	–	Für Cloud SQL for MySQL ist keine entsprechende Funktion verfügbar. Verschieben Sie diese Logik in die Anwendungsebene.
REGEXP_INSTR	Durchsucht eine Stringposition (Index) nach einem Muster eines regulären Ausdrucks.	Nein	–	Wird ab MySQL-Version 8 unterstützt. Wenn Sie eine ältere Version verwenden, verschieben Sie diese Logik in die Anwendungsebene.
REVERSE	Gibt den umgekehrten String für einen bestimmten String zurück: REVERSE('MySQL') = LQSyM	Ja	REVERSE	REVERSE('MySQL') = LQSyM

In der folgenden Tabelle wird beschrieben, in welchen Fällen numerische Funktionen von Oracle und Cloud SQL for MySQL nach Name und Funktionalität vergleichbar sind und wann eine Konvertierung empfohlen wird.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Entsprechung	Cloud SQL for MySQL-Funktion	Umsetzung in Cloud SQL for MySQL
ABS	Gibt den absoluten Wert einer bestimmten Zahl zurück: ABS(-4.6) = 4.6	Ja	ABS	ABS(-4.6) = 4.6
CEIL	Gibt die kleinste Ganzzahl zurück, die größer oder gleich der angegebenen Zahl ist: CEIL(21.4) = 22	Ja	CEIL	CEIL(21.4) = 22
FLOOR	Gibt die größte Ganzzahl zurück, die kleiner oder gleich der angegebenen Zahl ist: FLOOR(-23.7) = -24	Ja	FLOOR	FLOOR(-23.7) = -24
MOD	Gibt den Rest von m geteilt durch n zurück: MOD(10, 3) = 1	Ja	MOD	MOD(10, 3) = 1
ROUND	Gibt n zurück, gerundet auf Ganzzahlen rechts vom Dezimalzeichen: ROUND(1.39, 1) = 1.4	Ja	ROUND	ROUND(1.39, 1) = 1.4
TRUNC(Zahl)	Gibt n1 zurück, abgeschnitten auf n2 Dezimalstellen. Der zweite Parameter ist optional. TRUNC(99.999) = 99 TRUNC(99.999, 0) = 99	Erfordert einen anderen Funktionsnamen.	TRUNCATE(Zahl)	Die Funktion von Cloud SQL for MySQL hat einen anderen Namen und der zweite Parameter ist obligatorisch. TRUNCATE(99.999, 0) = 99

In der folgenden Tabelle wird beschrieben, in welchen Fällen datetime-Funktionen von Oracle und Cloud SQL for MySQL nach Name und Funktionalität vergleichbar sind und wann eine Konvertierung empfohlen wird.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Entsprechung	Cloud SQL for MySQL-Funktion	Umsetzung in Cloud SQL for MySQL
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	Ja	SYSDATE()	Das SYSDATE() von Cloud SQL for MySQL muss Klammern enthalten und gibt standardmäßig ein anderes datetime-Format als die Funktion SYSDATE von Oracle zurück: SELECT SYSDATE() FROM DUAL; = 2019-01-31 10:01:01.0 Sie können das datetime-Format auf Sitzungsebene ändern.
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	Erfordert einen anderen Funktionsnamen.	CURRENT_ TIMESTAMP	Die Funktion von Cloud SQL for MySQL gibt standardmäßig ein anderes datetime-Format zurück. Verwenden Sie die Funktion DATE_FORMAT(), um die Ausgabe neu zu formatieren. SELECT CURRENT_TIMESTAMP FROM DUAL; = 2019-01-31 06:55:07
LOCAL_ TIMESTAMP	Gibt das aktuelle Datum und die aktuelle Uhrzeit als Typ TIMESTAMP zurück: SELECT LOCALTIMESTAMP FROM DUAL = 01-JAN-19 10.01.10.123456 PM	Gibt ein anderes datetime-Format zurück.	LOCAL_ TIMESTAMP	Die Funktion von Cloud SQL for MySQL gibt ein anderes datetime-Format als das Standardformat für Oracle zurück. Verwenden Sie die Funktion DATE_FORMAT(), um die Ausgabe neu zu formatieren. SELECT LOCAL_TIMESTAMP FROM DUAL = 2019-01-01 10:01:01.0
CURRENT_DATE	Gibt das aktuelle Datum zurück: SELECT CURRENT_DATE FROM DUAL = 31-JAN-19	Gibt ein anderes datetime-Format zurück.	CURRENT_ DATE	Die Funktion von Cloud SQL for MySQL gibt ein anderes datetime-Format zurück. Verwenden Sie die Funktion DATE_FORMAT(), um die Ausgabe neu zu formatieren. SELECT CURRENT_DATE FROM DUAL = 2019-01-31
CURRENT_ TIMESTAMP	Gibt das aktuelle Datum und die aktuelle Uhrzeit zurück: SELECT CURRENT_TIMESTAMP FROM DUAL = 31-JAN-19 06.54.35.543146 AM +00:00	Gibt ein anderes datetime-Format zurück.	CURRENT_ TIMESTAMP	Die Funktion von Cloud SQL for MySQL gibt ein anderes datetime-Format zurück. Verwenden Sie die Funktion DATE_FORMAT(), um die Ausgabe neu zu formatieren. 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	Erfordert einen anderen Funktionsnamen.	ADDDATE	Die Funktion von Cloud SQL for MySQL gibt ein anderes datetime-Format zurück. Verwenden Sie die Funktion DATE_FORMAT(), um die Ausgabe neu zu formatieren. ADDDATE(SYSDATE(), 1) = 2019-08-01 06:42:49.0
EXTRACT (Datumsteil)	Gibt den Wert eines datetime-Felds basierend auf einem Intervallausdruck zurück: EXTRACT(YEAR FROM DATE '2019-01-31') = 2019	Ja	EXTRACT (Datumsteil)	EXTRACT(YEAR FROM DATE '2019-01-31') = 2019
LAST_DAY	Gibt den letzten Tag des Monats für ein bestimmtes Datum zurück: LAST_DAY('01-JAN-2019') = 31-JAN-19	Teilweise	LAST_DAY	Die Funktion von Cloud SQL for MySQL gibt ein anderes datetime-Format als das Standardformat für Oracle zurück. Verwenden Sie die Funktion DATE_FORMAT(), um die Ausgabe neu zu formatieren. LAST_DAY('2019-01-01') = 2019-01-31
MONTH_ BETWEEN	Gibt die Anzahl der Monate zwischen den angegebenen Daten date1 und date2: MONTHS_BETWEEN( SYSDATE, SYSDATE-60) = 1.96 zurück:	Teilweise	PERIOD_DIFF	Die PERIOD_DIFF-Funktion von Cloud SQL for MySQL gibt die Differenz in Monaten zwischen zwei Zeitpunkten im Format YYMM oder YYYYMM als Ganzzahl zurück: PERIOD_DIFF( '201903', '201901') = 2
TO_CHAR (Datetime)	Wandelt eine Zahl, datetime, oder einen Zeitstempeltyp in einen String-Typ um: TO_CHAR( SYSDATE,'DD-MM-YYYY HH24:MI:SS') = 01-01-2019 10:01:01	Erfordert einen anderen Funktionsnamen.	DATE_FORMAT	Die DATE_FORMAT-Funktion von Cloud SQL for MySQL formatiert einen Datumswert gemäß einem Formatstring: DATE_FORMAT( SYSDATE(),'%d-%m-%Y %H:%i:%s') 01-01-2019 10:01:01

In der folgenden Tabelle wird beschrieben, in welchen Fällen Codierungs- und Decodierungsfunktionen von Oracle und Cloud SQL for MySQL nach Name und Funktionalität vergleichbar sind und wann eine Konvertierung empfohlen wird.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Entsprechung	Cloud SQL for MySQL-Funktion	Umsetzung in Cloud SQL for MySQL
DECODE	Vergleicht den Ausdruck anhand der Funktionalität einer IF-THEN-ELSE-Anweisung einzeln mit jedem Suchwert.	Nein	CASE	Verwenden Sie für eine ähnliche Funktionalität die CASE-Anweisung von Cloud SQL for MySQL.
DUMP	Gibt einen VARCHAR2-Wert zurück, der den Datentypcode, die Länge in Byte und die interne Darstellung des Ausdrucks enthält.	Nein	–	Nicht unterstützt
ORA_HASH	Berechnet einen Hash-Wert für einen bestimmten Ausdruck.	Nein	MD5 or SHA	Verwenden Sie die Funktion MD5 für 128-Bit-Prüfsummen oder die Funktion SHA für 160-Bit-Prüfsummen.

In der folgenden Tabelle wird beschrieben, in welchen Fällen Konvertierungsfunktionen von Oracle und Cloud SQL for MySQL nach Name und Funktionalität vergleichbar sind und wann eine Konvertierung empfohlen wird.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Entsprechung	Cloud SQL for MySQL-Funktion	Umsetzung in Cloud SQL for MySQL
CAST	Konvertiert einen integrierten Datentyp oder Sammlungstypwert in einen anderen integrierten Datentyp oder Sammlungstypwert: CAST('1' as int) + 1 = 2	Teilweise	CAST	Je nachdem, ob eine explizite oder implizite Konvertierung erforderlich ist, muss eine Anpassung erfolgen: CAST('1' AS SIGNED) + 1 = 2
CONVERT	Wandelt einen Zeichenstring von einem Zeichensatz in einen anderen um: CONVERT ( 'Ä Ê Í Õ Ø A B C D E ', 'US7ASCII', 'WE8ISO8859P1') = ?? ?? ?? A B C	Teilweise	CONVERT	Die CONVERT-Funktion von Cloud SQL for MySQL erfordert einige Anpassungen der Syntax und der Parameter: 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 FORMAT-Funktion von Cloud SQL for MySQL konvertiert eine Zahl in ein Format wie #,###,###.##, rundet sie auf eine Dezimalstelle und gibt dann das Ergebnis als String zurück: CONCAT('$', FORMAT(22.73, 1)) = $22.7
TO_DATE	Die TO_DATE-Funktion von Oracle wandelt einen String basierend auf dem datetimecode-Format in ein Datum um: TO_DATE( '2019/01/01', 'yyyy-mm-dd') = 01-JAN-2019	Erfordert einen anderen Funktionsnamen.	STR_TO_DATE	Die STR_TO_DATE-Funktion von Cloud SQL for MySQL nimmt einen String und gibt ein Datum basierend auf dem datetime-Format zurück: STR_TO_DATE( '2019/01/01', '%Y/%m/%d') = 2019-01-01
TO_NUMBER	Wandelt den Ausdruck in einen Wert des Datentyps NUMBER um: TO_NUMBER('01234') = 1234	Erfordert einen anderen Funktionsnamen.	CAST	Verwenden Sie die CAST-Funktion von Cloud SQL for MySQL, um dasselbe Ergebnis wie bei der TO_NUMBER-Funktion von Oracle zurückzugeben: CAST('01234' as SIGNED) = 1234

In der folgenden Tabelle wird beschrieben, in welchen Fällen bedingte SELECT-Funktionen von Oracle und Cloud SQL for MySQL nach Name und Funktionalität vergleichbar sind und wann eine Konvertierung empfohlen wird.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Entsprechung	Cloud SQL for MySQL-Funktion	Umsetzung in Cloud SQL for MySQL
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 Cloud SQL for MySQL die Verwendung der bedingten IF/ELSE-Verarbeitung in der Anweisung SELECT: CASE WHEN condition THEN result [WHEN ...] [ELSE result] END

In der folgenden Tabelle wird beschrieben, in welchen Fällen Nullfunktionen von Oracle und Cloud SQL for MySQL nach Name und Funktionalität vergleichbar sind und wann eine Konvertierung empfohlen wird.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Entsprechung	Cloud SQL for MySQL-Funktion	Umsetzung in Cloud SQL for MySQL
COALESCE	Gibt den ersten Nicht-Null-Ausdruck in der Ausdrucksliste zurück: COALESCE( null, '1', 'a') = a	Ja	COALESCE	COALESCE( null, '1', 'a') = 1
NULLIF	Führt einen Vergleich zwischen expression1 und expression2 durch. Wenn die Werte gleich sind, gibt die Funktion null zurück. Wenn sie nicht gleich sind, gibt die Funktion expression1 zurück: NULLIF('1', '2') = a	Ja	NULLIF	NULLIF('1', '2') = a
NVL	Ersetzt einen null-Wert in den Ergebnissen einer Abfrage durch einen String: NVL(null, 'a') = a	Nein	IFNULL	IFNULL(null, 'a') = a
NVL2	Bestimmt den von einer Abfrage zurückgegebenen Wert basierend darauf, ob ein Ausdruck null ist oder nicht.	Nein	CASE	Bei der Anweisung CASE wird aus einer Reihe von Bedingungen eine Auswahl getroffen und eine entsprechende Anweisung ausgeführt: CASE WHEN condition THEN result [WHEN ...] [ELSE result] END

In der folgenden Tabelle wird beschrieben, in welchen Fällen Umgebungs- und Kennungsfunktionen von Oracle und Cloud SQL for MySQL nach Name und Funktionalität vergleichbar sind und wann eine Konvertierung empfohlen wird.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Entsprechung	Cloud SQL for MySQL-Funktion	Umsetzung in Cloud SQL for MySQL
SYS_GUID	Generiert eine global eindeutige Kennung (RAW-Wert), die aus 16 Byte besteht: SELECT SYS_GUID() FROM DUAL = 8EFA4A31468B4C6DE05011AC0200009E	Nein	REPLACE und UUID	Verwenden Sie als Behelfslösung die Funktionen REPLACE und UUID, um die Funktion SYS_GUID zu simulieren: REPLACE( UUID(), '-', '')
UID	Gibt eine Ganzzahl zurück, mit der der Sitzungsnutzer (der angemeldete Nutzer) eindeutig identifiziert werden kann: SELECT UID FROM DUAL = 43	Nein	–	–
USER	Gibt den Nutzernamen des Nutzers zurück, der mit der aktuellen Sitzung verbunden ist: SELECT USER FROM DUAL = username	Ja	USER + INSTR + SUBSTR	Die USER-Funktion von Cloud SQL for MySQL gibt den Nutzernamen und den Hostnamen (root@IP_ADDRESS) für die Verbindung 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 Oracle-Sitzung zurück, z. B. die Sprache der Sitzung: SELECT USERENV('LANGUAGE') FROM DUAL = ENGLISH_AMERICA. AL32UTF8	Nein	SHOW SESSION VARIABLES	Die SHOW SESSION VARIABLES-Anweisung von Cloud SQL for MySQL gibt die Einstellungen für die aktuelle Sitzung zurück: SHOW SESSION VARIABLES LIKE '%collation%'; = utf8_general_ci
ROWID	Oracle weist jeder Zeile einer Tabelle eine eindeutige ROWID zu, damit die Zeile in der Tabelle identifiziert werden kann. ROWID ist die Adresse der Zeile, die die Datenobjektnummer, den Datenblock der Zeile, die Zeilenposition und die Datendatei enthält.	Teilweise	–	ROW_NUMBER() ist ab MySQL 8.0 verfügbar. Wenn Sie eine frühere Version verwenden, emulieren Sie dieselbe Funktionalität mithilfe der Sitzungsvariablen @row_number.
ROWNUM	Gibt eine Zahl zurück, die die Reihenfolge darstellt, in der eine Zeile von einer Oracle-Tabelle zurückgegeben wird.	Teilweise	–	ROW_NUMBER() ist ab MySQL 8.0 verfügbar. Wenn Sie eine frühere Version verwenden, emulieren Sie dieselbe Funktionalität mithilfe der Sitzungsvariablen @row_number.

In der folgenden Tabelle wird beschrieben, in welchen Fällen Aggregat-(Gruppen-)funktionen von Oracle und Cloud SQL for MySQL nach Name und Funktionalität vergleichbar sind und wann eine Konvertierung empfohlen wird.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Entsprechnung	Cloud SQL for MySQL-Funktion	Umsetzung in Cloud SQL for MySQL
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 eines Werts einer Spalte oder eines Ausdrucks zurück.	Ja	SUM	Entsprechung zu Oracle
LISTAGG	Sortiert die Daten innerhalb jeder Gruppe, die in der ORDER BY-Klausel angegeben ist, und verkettet die Werte der Messwertspalte: SELECT LISTAGG( DEPARTMENT_NAME, ', ') WITHIN GROUP (ORDER BY DEPARTMENT_NAME) DEPT FROM DEPARTMENTS; -- Single line results = Accounting, Administration, Benefits, Construction	Erfordert einen anderen Funktionsnamen und eine andere Syntax.	GROUP_ CONCAT	Verwenden Sie die GROUP_CONCAT-Funktion von Cloud SQL for MySQL, um gleichwertige Ergebnisse zurückzugeben: SELECT GROUP_CONCAT( DEPARTMENT_NAME ORDER BY DEPARTMENT_NAME SEPARATOR ', ') DEPT FROM DEPARTMENTS; -- Single line results = Accounting, Administration, Benefits, Construction

In der folgenden Tabelle wird beschrieben, in welchen Fällen die FETCH-Funktion von Oracle und Cloud SQL for MySQL nach Name und Funktionalität vergleichbar ist.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Entsprechung	Cloud SQL for MySQL-Funktion	Umsetzung in Cloud SQL for MySQL
FETCH	Ruft eine bestimmte Anzahl von Zeilen aus der Ergebnismenge einer mehrzeiligen Abfrage ab: SELECT * FROM EMPLOYEES FETCH FIRST 10 ROWS ONLY;	Ja	LIMIT	Verwenden Sie die MySQL-Klausel LIMIT, um Zeilen aus einer Abfrage abzurufen: SELECT * FROM EMPLOYEES LIMIT 10;

Grundlegende Filter, Operatoren und Unterabfragen

Grundlegende Filter, Operatorenfunktionen und Unterabfragen lassen sich relativ einfach umwandeln. Der Aufwand ist minimal. Der Großteil des Aufwands fällt bei der Konvertierung von Datumsformaten an, da Oracle und Cloud SQL for MySQL für das Datum unterschiedliche Standardformate verwenden:

• Die SYSDATE-Funktion von Oracle gibt standardmäßig dieses Format zurück: 01-AUG-19.
• Die SYSDATE()-Funktion von Cloud SQL for MySQL gibt standardmäßig dieses Format zurück: 2019-08-01 12:04:05.

Verwenden Sie zum Festlegen von Datums- und Uhrzeitformaten die MySQL-Funktionen DATE_FORMAT oder STR_TO_DATE.

In der folgenden Tabelle wird beschrieben, in welchen Fällen grundlegende Filter-, Operatoren- und Unterabfragefunktionen von Oracle und Cloud SQL for MySQL nach Name und Funktionalität vergleichbar sind und wann eine Konvertierung empfohlen wird.

Oracle-Funktion	Umsetzung in Oracle	Cloud SQL for MySQL-Entsprechung	Cloud SQL for MySQL-Funktion
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	Cloud SQL for MySQL unterstützt Unterabfragen in der Klausel SELECT, in der Klausel JOIN 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	Cloud SQL for MySQL unterstützt alle grundlegenden Operatoren: > | >= | < | <= | = | <> | !=

Best Practices für Cloud SQL for MySQL-Abfragen

Damit die Leistung von Cloud SQL for MySQL und Oracle vergleichbar bleibt, müssen Sie möglicherweise Ihre Abfragen optimieren. Zu diesen Optimierungen gehören das Ändern der Indexstrukturen und das Anpassen des Datenbankschemas. Dieser Abschnitt enthält einige Richtlinien, mit denen Sie in Cloud SQL for MySQL eine vergleichbare Abfrageleistung erreichen können.

Einen geclusterten Index erstellen

Bei Verwendung des Speichermoduls InnoDB empfiehlt es sich, eine Tabelle mit einem Primärschlüssel zu definieren, da dieser Schlüssel einen geclusterten Index für diese Tabelle erstellt. Mit diesem Ansatz können Sie nicht nur die Abfrageleistung verbessern, sondern auch zusätzliche sekundäre Indexe erstellen. Sie sollten es jedoch vermeiden, zu viele Indexe zu erstellen. Sind redundante Indexe vorhanden, verbessert sich die Leistung nicht und die DML-Ausführung erfolgt langsamer. Diese Best Practice führt zu einer zweiten Best Practice: Suchen Sie regelmäßig nach redundanten Indexen. Sind redundante Indexe vorhanden, löschen Sie diese aus der Datenbank.

Verwenden Sie die folgende Abfrage, um Tabellen ohne Primärschlüssel zu identifizieren, sodass Sie Primärschlüssel für sie erstellen können:

mysql> SELECT t.table_schema, t.table_name
       FROM information_schema.tables t LEFT JOIN
       information_schema.statistics s
       ON t.table_schema=s.table_schema AND t.table_name=s.table_name
       AND s.non_unique=0
       WHERE s.table_name IS NULL
       AND t.table_schema NOT IN('sys', 'information_schema', 'mysql',
       'performance_schema')
       AND t.`TABLE_TYPE` <> 'VIEW';

Verwenden Sie die folgende Abfrage, um nach Tabellen ohne Indexe zu suchen, sodass Sie Indexe für sie erstellen können:

mysql> SELECT t.table_schema, t.table_name FROM INFORMATION_SCHEMA.tables t
       WHERE table_name NOT IN
             (SELECT  table_name FROM (
                      SELECT  table_name, index_name
                      FROM information_schema.statistics
                  GROUP BY  table_name, index_name) tab_ind_cols
           GROUP BY table_name)
AND table_schema NOT IN('sys', 'information_schema', 'mysql', 'performance_schema')
AND TABLE_TYPE <> 'VIEW';

Verwenden Sie die folgende Abfrage, um nach redundanten Indexen zu suchen, damit Sie die Redundanzen entfernen können:

mysql> SELECT * FROM sys.schema_redundant_indexes;

Suchparameter anpassen

Zum Optimieren der Abfrageleistung müssen Sie möglicherweise die Sitzungsparameter anpassen. Cloud SQL for MySQL verfügt über eine Reihe von Flags, die Sie zu diesem Zweck ändern können, einschließlich der folgenden Flags:

• InnoDB-bezogene Parameter
• SORT Parameter
• JOIN Parameter
• Parameter für die Cache-Verarbeitung

Abfragen beobachten

Abfragen mit langsamer Ausführung können dazu führen, dass das System nicht mehr reagiert oder andere Engpässe auftreten. Daher ist es wichtig, Abfragen regelmäßig zu beobachten.

Es gibt mehrere Möglichkeiten, langsam ausgeführte SQL-Anweisungen zu diagnostizieren:

• Verwenden Sie das Dashboard von Cloud SQL for MySQL, um Echtzeit- und Verlaufsinformationen zu langsam ausgeführten Abfragen zu erhalten.
• Verwenden Sie Cloud Monitoring, um das Log von Cloud SQL for MySQL für langsame Abfragen im Blick zu behalten.

• Verwenden Sie die Ansicht statement_analysis von Cloud SQL for MySQL, um die Laufzeitstatistiken zu einer SQL-Anweisung aufzurufen:

  mysql> SELECT * FROM sys.statement_analysis;
  

Cloud SQL for MySQL-Abfragen analysieren

Das Tool zur Abfrageoptimierung in Cloud SQL for MySQL generiert einen Ausführungsplan für die Anweisungen SELECT, INSERT, UPDATE und DELETE. Diese Pläne sind hilfreich, wenn Sie eine langsam ausgeführte Abfrage anpassen. Dabei müssen einige Aspekte berücksichtigt werden:

• Ausführungspläne sind keine Datenbankobjekte, die migriert werden müssen. Sie sind vielmehr ein Tool zum Analysieren von Leistungsunterschieden zwischen Oracle und Cloud SQL for MySQL, die dieselbe Anweisung für identische Datasets ausführen.
• Cloud SQL for MySQL unterstützt nicht die gleiche Syntax, Funktionalität oder Ausgabe des Ausführungsplans wie Oracle.

Hier ist ein Beispielplan, der die Unterschiede zwischen einem Ausführungsplan von Oracle und einem Ausführungsplan von Cloud SQL for MySQL veranschaulicht:

SQL> EXPLAIN PLAN FOR
     SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 105;

SQL> SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY (FORMAT=>'ALL +OUTLINE'));

Plan hash value: 1833546154

---------------------------------------------------------------------------------------------
| Id  | Operation                   | Name          | Rows  | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT            |               |     1 |    69 |     1   (0)| 00:00:01 |
|   1 |  TABLE ACCESS BY INDEX ROWID| EMPLOYEES     |     1 |    69 |     1   (0)| 00:00:01 |
|*  2 |   INDEX UNIQUE SCAN         | EMP_EMP_ID_PK |     1 |       |     0   (0)| 00:00:01 |
---------------------------------------------------------------------------------------------

mysql> EXPLAIN SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 105;

+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
| id | select_type | table     | partitions | type  | possible_keys | key     | key_len | ref   | rows | filtered | Extra |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
|  1 | SIMPLE      | EMPLOYEES | NULL       | const | PRIMARY       | PRIMARY | 3       | const |    1 |   100.00 | NULL  |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+

Gespeicherte Verfahren und Trigger optimieren

Im Gegensatz zu Oracle werden gespeicherte Verfahren und Funktionen von Cloud SQL for MySQL bei jeder Ausführung geparst. Ein hilfreiches Tool zum Benchmarking von gespeicherten Verfahren und Funktionen ist das BENCHMARK()-Dienstprogramm von MySQL. Dieses Tool nimmt zwei Parameter, einen Iterationszähler sowie einen Ausdruck und erstellt eine Schätzung der Laufzeit des angegebenen Ausdrucks (z. B. gespeicherte Verfahren, Funktionen und die Anweisung SELECT). Die Ausgabe stellt die ungefähre Gesamtlaufzeit über alle Iterationen dar.

Das folgende Beispiel dient zur Veranschaulichung des BENCHMARK()-Dienstprogramms:

-- SELECT Expression Example

mysql> select benchmark(10000000, 'select sysdate()');
+-----------------------------------------+
| benchmark(10000000, 'select sysdate()') |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
1 row in set (0.12 sec)

-- Result: Run time of 0.12 sec for 1,0000,000 iterations

-- FUNCTION Example
mysql> select benchmark(1000000, func1());
+-----------------------------+
| benchmark(1000000, func1()) |
+-----------------------------+
|                           0 |
+-----------------------------+
1 row in set (2.54 sec)

-- Result: Run time of 2.54 sec for 1,000,000 iterations

Wenn Sie während der Konvertierung einen Leistungsrückgang feststellen, können Sie mit dem MySQL-Befehl EXPLAIN mögliche Faktoren ermitteln, die zu diesem Rückgang beitragen. Eine gängige Lösung für eine schwache Leistung besteht darin, die Struktur eines Tabellenindexes an das MySQL-Optimierungstool anzupassen. Eine weitere gängige Vorgehensweise besteht darin, einen konvertierten PL/SQL-Code zu optimieren, indem unnötige Datenabrufe reduziert oder im prozessualen MySQL-Code temporäre Tabellen verwendet werden.

Nächste Schritte

• Weitere Informationen zu MySQL-Nutzerkonten lesen.
• Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center