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

Dieses Dokument ist Teil einer Reihe, die wichtige Informationen und Anleitungen zur Planung und Durchführung von Oracle® 11g/12c-Datenbankmigrationen zu Cloud SQL for PostgreSQL Version 12 enthält. Zusätzlich zum Teil der anfänglichen Einrichtung umfasst die Reihe die folgenden Teile:

Oracle-Nutzer zu Cloud SQL for PostgreSQL migrieren: Terminologie und Funktionalität
Oracle-Nutzer zu Cloud SQL for PostgreSQL migrieren: Datentypen, Nutzer und Tabellen
Oracle-Nutzer zu Cloud SQL for PostgreSQL migrieren: Abfragen, gespeicherte Verfahren, Funktionen und Trigger (dieses Dokument)
Oracle-Nutzer zu Cloud SQL for PostgreSQL migrieren: Sicherheit, Vorgänge, Monitoring und Logging
Oracle Database-Nutzer und -Schemas zu Cloud SQL for PostgreSQL migrieren

Abfragen

Oracle und Cloud SQL for PostgreSQL unterstützen den ANSI SQL-Standard. Daher ist es im Allgemeinen unkompliziert, SQL-Anweisungen mithilfe von einfachen Syntaxelementen zu migrieren, z. B. keine Skalarfunktionen oder andere erweiterte Oracle-Funktionen angeben. Im folgenden Abschnitt werden gängige Oracle-Abfrageelemente und die jeweiligen Entsprechungen in Cloud SQL for PostgreSQL erläutert.

Grundlegende SELECT- und FROM-Syntax

Feature- oder Syntaxname von Oracle	Überblick oder Implementierung von Oracle	Unterstützung für Cloud SQL for PostgreSQL	Entsprechung oder alternative Lösung für Cloud SQL for PostgreSQL
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`
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).	Ja	Bei Namen wird die Groß-/Kleinschreibung nicht berücksichtigt außer sie werden in Anführungszeichen gesetzt, z. B. werden `orders` und `ORDERS` gleich behandelt, während `"orders"` und `"ORDERS"` unterschiedlich behandelt werden.

Weitere Informationen zur Syntax von Cloud SQL for PostgreSQL für SELECT finden Sie in der Dokumentation.

Inline-Ansichten

Inline-Ansichten (auch als abgeleitete Tabellen bezeichnet) sind SELECT-Anweisungen in der FROM-Klausel, die als Unterabfragen 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.
Hinweis zur Konvertierung: Für Oracle-Inline-Ansichten ist keine Verwendung von Aliassen erforderlich. Für Cloud SQL for PostgreSQL sind dagegen bestimmte Aliasse für jede Inline-Ansicht erforderlich.

Die folgende Tabelle enthält ein Konvertierungsbeispiel von Oracle zu Cloud SQL for PostgreSQL als Inline-Ansicht.

Oracle 11g/12c Cloud SQL for PostgreSQL 12

Oracle 11g/12c	Cloud SQL for PostgreSQL 12
`SQL> SELECT FIRST_NAME, DEPARTMENT_ID, SALARY, DATE_COL FROM EMPLOYEES, (SELECT SYSDATE AS DATE_COL FROM DUAL);` Die Ausgabe sieht in 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`	Ohne Alias für die Inline-Ansicht: `postgres=> SELECT FIRST_NAME, postgres-> DEPARTMENT_ID, postgres-> SALARY, postgres-> DATE_COL postgres-> FROM EMPLOYEES, (SELECT NOW() AS DATE_COL); ERROR: subquery in FROM must have an alias LINE 5: FROM EMPLOYEES, (SELECT NOW() AS DATE_COL); HINT: For example, FROM (SELECT ...) [AS] foo.` Mit hinzugefügtem Alias für die Inline-Ansicht: `postgres=> SELECT FIRST_NAME, postgres-> DEPARTMENT_ID, postgres-> SALARY, postgres-> DATE_COL postgres-> FROM EMPLOYEES, (SELECT NOW() AS DATE_COL) AS C1;` Die Ausgabe sieht in etwa so aus: `first_name \| department_id \| salary \| date_col -------------+---------------+----------+-------------------------------- Steven \| 90 \| 24000.00 \| 10/16/2020 08:35:18.470089 UTC Neena \| 90 \| 17000.00 \| 10/16/2020 08:35:18.470089 UTC Lex \| 90 \| 17000.00 \| 10/16/2020 08:35:18.470089 UTC`

SQL> SELECT FIRST_NAME,

            DEPARTMENT_ID,

            SALARY,

            DATE_COL

     FROM EMPLOYEES,

  (SELECT SYSDATE AS DATE_COL FROM DUAL);

Die Ausgabe sieht in 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

Ohne Alias für die Inline-Ansicht:

postgres=> SELECT FIRST_NAME,

postgres->             DEPARTMENT_ID,

postgres->             SALARY,

postgres->             DATE_COL

postgres-> FROM EMPLOYEES, (SELECT NOW() AS DATE_COL);



ERROR:  subquery in FROM must have an alias

LINE 5: FROM EMPLOYEES, (SELECT NOW() AS DATE_COL);



HINT:  For example, FROM (SELECT ...) [AS] foo.

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

postgres=> SELECT FIRST_NAME,

postgres->             DEPARTMENT_ID,

postgres->             SALARY,

postgres->             DATE_COL

postgres-> FROM EMPLOYEES, (SELECT NOW() AS DATE_COL) AS C1;

Die Ausgabe sieht in etwa so aus:


 first_name  | department_id |  salary  |            date_col

-------------+---------------+----------+--------------------------------

 Steven      |            90 | 24000.00 | 10/16/2020 08:35:18.470089 UTC

 Neena       |            90 | 17000.00 | 10/16/2020 08:35:18.470089 UTC

 Lex         |            90 | 17000.00 | 10/16/2020 08:35:18.470089 UTC

JOIN-Anweisungen

Oracle-JOIN-Anweisungen werden von Cloud SQL for PostgreSQL-JOIN-Anweisungen unterstützt. Die Verwendung des Oracle-Join-Operators (+) wird von Cloud SQL for PostgreSQL jedoch nicht unterstützt. Für das gleiche Ergebnis müssen Sie in die Standard-SQL-Syntax für Outer Joins konvertieren.

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

JOIN-Typ von Oracle	Von Cloud SQL for PostgreSQL unterstützt	JOIN-Syntax von Cloud SQL for PostgreSQL
`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 [ OUTER ]`	Ja	`SELECT E.FIRST_NAME, D.DEPARTMENT_NAME FROM EMPLOYEES E FULL 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;`

UNION, UNION ALL, INTERSECT und MINUS

Cloud SQL for PostgreSQL unterstützt die Operatoren UNION, UNION ALL und INTERSECT von Oracle. Der Operator MINUS wird nicht unterstützt. In Cloud SQL for PostgreSQL wird jedoch der Operator EXCEPT implementiert, der dem Operator MINUS in Oracle entspricht. Darüber hinaus unterstützt Cloud SQL for PostgreSQL die Operatoren INTERSECT ALL und EXCEPT ALL, die von Oracle nicht unterstützt werden.

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. Doppelte Datensätze werden nicht gelöscht.
INTERSECT ALL (nur für Cloud SQL for PostgreSQL): Gibt die Schnittmenge von zwei oder mehr SELECT-Anweisungen nur zurück, wenn ein Datensatz in beiden Datasets vorhanden ist.
MINUS (EXCEPT in Cloud SQL for PostgreSQL: Vergleicht zwei oder mehr SELECT-Anweisungen und gibt nur bestimmte Zeilen aus der ersten Abfrage zurück, die von den anderen Anweisungen nicht zurückgegeben werden.
EXCEPT ALL (nur Cloud SQL for PostgreSQL): Vergleicht zwei oder mehr SELECT-Anweisungen und gibt nur Zeilen aus der ersten Abfrage zurück, die nicht von den anderen Anweisungen zurückgegeben werden, ohne doppelte Datensätze zu entfernen.

Konvertierungshinweise

Wenn Sie von Oracle MINUS-Operatoren in Cloud SQL for PostgreSQL umwandeln, verwenden Sie stattdessen die EXCEPT-Operatoren.

Beispiele

Oracle-Funktion	Umsetzung in Oracle	Unterstützung für Cloud SQL for PostgreSQL	Entsprechung oder alternative Lösung für Cloud SQL for PostgreSQL
`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`	Ja	`SELECT COL1 FROM TBL1 INTERSECT SELECT COL1 FROM TBL2`
`MINUS`	`SELECT COL1 FROM TBL1 MINUS SELECT COL1 FROM TBL2`	Ja (`Convert MINUS` bis `EXCEPT` in PostgreSQL)	`SELECT COL1 FROM TBL1 EXCEPT SELECT COL1 FROM TBL2`

Skalar- (einzeilige) und Gruppenfunktionen

Cloud SQL for PostgreSQL bietet eine umfassende Liste von (einzeiligen) Skalierungs- und Aggregationsfunktionen. Einige Funktionen von Cloud SQL for PostgreSQL sind ihren Entsprechungen von Oracle recht ähnlich (nach Name und Funktionalität oder unter einem anderen Namen, aber mit ähnlicher Funktionalität). Obwohl Cloud SQL for PostgreSQL-Funktionen identische Namen wie ihre Oracle-Gegenstücken haben können, haben sie manchmal unterschiedliche Funktionen.

In den folgenden Tabellen wird beschrieben, in welchen Fällen Funktionen von Oracle und Cloud SQL for PostgreSQL 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	Cloud SQL for PostgreSQL-Äquivalent	Entsprechende Cloud SQL for PostgreSQL-Funktion	Funktionsspezifikation oder -Implementierung von Cloud SQL for PostgreSQL
`CONCAT`	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`	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`	Gibt einen Teil von char zurück, beginnend an der Zeichenposition, wobei der Teilstring - Zeichen lang ist: `SUBSTR('PostgreSQL', 8, 3) = SQL`	Teilweise	`SUBSTR`	Wie bei Oracle, wenn die Startposition eine positive Zahl ist. `SUBSTR('PostgreSQL', 8, 3) = SQL` Wenn eine negative Zahl als Startposition in Oracle angegeben wird, führt sie einen Teilstringvorgang vom Ende des Strings aus, was sich von Cloud SQL for PostgreSQL unterscheidet. Verwenden Sie die Funktion `RIGHT` als Ersatz, wenn das Verhalten von Oracle erwünscht ist.
`INSTR`	Gibt die Position (Index) eines Strings aus einem bestimmten String zurück: `INSTR('PostgreSQL', 'e') = 7`	Nein	–	Cloud SQL for PostgreSQL verfügt nicht über eine integrierte `instr`-Funktion. Eine Oracle-kompatible `instr`-Funktion kann mit PL/pgSQL implementiert werden.
`REPLACE`	Gibt "char" zurück, wobei jeder vorkommende Suchstring durch einen Ersatzstring ersetzt wird: `REPLACE('ORADB', 'ORA', 'PostgreSQL') = PostgreSQLDB`	Teilweise	`REPLACE`	Der Ersatzstringparameter ist in Oracle optional, während er in Cloud SQL for PostgreSQL obligatorisch ist. Wenn der Parameter weggelassen wird, entfernt Oracle alle Vorkommen der Suchstrings. Dasselbe Verhalten könnte in Cloud SQL for PostgreSQL erreicht werden, indem ein leerer String als Ersatzstring angegeben wird. `REPLACE('ORADB', 'ORA', 'PostgreSQL') = PostgreSQLDB`
`TRIM`	Kürzt vor- oder nachgestellte Zeichen (oder beides) aus einem String: `TRIM(both '-' FROM '-PostgreSQL-') = PostgreSQL TRIM(' PostgreSQL ') = PostgreSQL`	Ja	`TRIM`	Entsprechung zu Oracle: `TRIM(both '-' FROM '-PostgreSQL-') = PostgreSQL TRIM(' PostgreSQL ') = PostgreSQL`
`LTRIM/RTRIM`	Entfernt von der linken oder rechten Seite eines Strings alle Zeichen, die bei der Suche vorkommen: `LTRIM(' PostgreSQL', ' ') = PostgreSQL`	Ja	`LTRIM/RTRIM`	Entsprechung zu Oracle: `LTRIM(' PostgreSQL', ' ') = PostgreSQL`
`ASCII`	Gibt die Dezimaldarstellung im Datenbank-Zeichensatz des ersten Zeichens von char zurück: `ASCII('A') = 65`	Ja	`ASCII`	Entsprechung zu Oracle: `ASCII('A') = 65`
`CHR`	Gibt den ASCII-Codewert für ein Zeichen zurück, der ein numerischer Wert zwischen 0 und 225 ist: `CHR(65) = A`	Ja	`CHAR`	Entsprechung zu Oracle: `CHR(65) = A`
`LENGTH`	Gibt die Länge eines bestimmten Strings zurück: `LENGTH ('PostgreSQL') = 10`	Ja	`LENGTH`	Entsprechung zu Oracle: `LENGTH ('PostgreSQL') = 10`
`REGEXP_REPLACE`	Sucht in einem String nach einem Muster eines regulären Ausdrucks: `REGEXP_REPLACE('John', '[hn].', '1') = Jo1`	Ja	`REGEXP_REPLACE`	Entsprechung zu Oracle: `REGEXP_REPLACE('John', '[hn].', '1') = Jo1`
`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	–	Verwenden Sie `REGEXP_MATCH` von PostgreSQL, um ähnliche Funktionen zu erzielen.
`REGEXP_COUNT`	Gibt zurück, wie häufig ein Muster in einem Quellstring vorkommt.	Nein	–	Verwenden Sie `REGEXP_MATCH` von PostgreSQL, um ähnliche Funktionen zu erzielen.
`REGEXP_INSTR`	Durchsucht eine Stringposition (Index) nach einem Muster eines regulären Ausdrucks.	Nein	–	Konvertieren Sie diese Funktionalität in die Anwendungsebene.
`REVERSE`	Gibt den umgekehrten String zurück `REVERSE('PostgreSQL') = LQSergtsoP`	Ja	`REVERSE`	Entsprechung zu Oracle: `REVERSE('PostgreSQL') = LQSergtsoP`

Numerische Funktionen

Oracle-Funktion	Oracle-Funktionsspezifikation oder -Implementierung	Cloud SQL for PostgreSQL-Äquivalent	Entsprechende Cloud SQL for PostgreSQL-Funktion	Funktionsspezifikation oder -Implementierung von Cloud SQL for PostgreSQL
`ABS`	Absoluter Wert von n: `ABS(-4.6) = 4.6`	Ja	`ABS`	Entsprechung zu Oracle: `ABS(-4.6) = 4.6`
`CEIL`	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`	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`	Gibt den Rest von `m` geteilt durch `n` zurück: `MOD(10, 3) = 1`	Ja	`MOD`	Entsprechung zu Oracle: `MOD(10, 3) = 1`
`ROUND`	Gibt n zurück, gerundet auf Ganzzahlen rechts vom Dezimalzeichen: `ROUND(1.39, 1) = 1.4`	Ja	`ROUND`	Entsprechung zu Oracle: `ROUND(1.39, 1) = 1.4`
`TRUNC` (Zahl)	Gibt n1 zurück, gekürzt auf n2 Dezimalstellen: `TRUNC(99.999) = 99 TRUNC(99.999, 0) = 99`	Ja	`TRUNCATE` (Zahl)	Entsprechung zu Oracle: `TRUNC(99.999) = 99 TRUNC(99.999, 0) = 99`

DATETIME-Funktionen

Oracle-Funktion	Oracle-Funktionsspezifikation oder -Implementierung	Cloud SQL for PostgreSQL-Äquivalent	Entsprechende Cloud SQL for PostgreSQL-Funktion	Funktionsspezifikation oder -Implementierung von Cloud SQL for PostgreSQL
`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 mit einem anderen Funktionsnamen und einer anderen Formatierung	`CURRENT_TIMESTAMP`	`CURRENT_TIMESTAMP` gibt ein anderes Datetime-Format als die SYSDATE-Funktion von Oracle zurück: `SELECT CURRENT_TIMESTAMP = 2019-07-31 06:46:40.171477+00`
`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`	Cloud SQL for PostgreSQL gibt ein anderes Datums-/Uhrzeitformat als Oracle zurück. Die Datumsformatierung muss dem ursprünglichen Datums-/Uhrzeitformat entsprechen: `SELECT CURRENT_TIMESTAMP = 2019-01-31 07:37:11.622187+00`
`LOCAL TIMESTAMP`	Gibt das aktuelle Datum und die aktuelle Uhrzeit in der Zeitzone der Sitzung in einem Wert vom Datentyp `TIMESTAMP` zurück: `SELECT LOCALTIMESTAMP FROM DUAL = 01-JAN-19 10.01.10.123456 PM`	Teilweise mit anderer Datums-/Uhrzeitformatierung	`LOCAL TIMESTAMP`	Cloud SQL for PostgreSQL gibt ein anderes Datums-/Uhrzeitformat als Oracle zurück. Die Datumsformatierung muss dem ursprünglichen Datums-/Uhrzeitformat entsprechen: `SELECT LOCALTIMESTAMP = 2019-01-31 07:37:11.622187+00`
`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`	Cloud SQL for PostgreSQL gibt ein anderes Datums-/Uhrzeitformat als Oracle zurück. Die Datumsformatierung muss dem ursprünglichen Datums-/Uhrzeitformat entsprechen: `SELECT CURRENT_DATE = 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`	Cloud SQL for PostgreSQL gibt ein anderes Datetime-Format als Oracle zurück. Die Datumsformatierung muss dem ursprünglichen Datetime-Format entsprechen: `SELECT CURRENT_TIMESTAMP FROM DUAL = 2019-01-31 07:37:11.622187+00s`
`ADD_MONTHS`	Gibt das Datum plus ganzzahlige Monate zurück: `ADD_MONTHS(SYSDATE, 1) = 31-JAN-19`	Nein	–	Um die gleiche Funktionalität in Cloud SQL for PostgreSQL zu erreichen, verwenden Sie die `+ / -`-Operatoren und geben Sie das Zeitintervall an: `SELECT CURRENT_TIMESTAMP + INTERVAL '1 MONTH' = 2019-01-31 07:37:11.622187+00s`
`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, das das angegebene Datum enthält: `LAST_DAY('01-JAN-2019') = 31-JAN-19`	Nein	–	Verwenden Sie als Behelfslösung `DATE_TRUNC` und einen `+`-Operator, um den letzten Tag des Monats zu berechnen. Die Datumsformatierung muss dem ursprünglichen Datums-/Uhrzeitformat entsprechen: `SELECT DATE_TRUNC('MONTH', DATE '01-JAN-2019') + INTERVAL '1 MONTH -1 DAY' = 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 Funktion unterschiedlicher Datums-/Uhrzeitformatierung	`AGE`	Die `AGE`-Funktion von Cloud SQL for PostgreSQL gibt das Intervall zwischen zwei Zeitstempeln zurück: `AGE(DATE '01-JAN-2019', DATE '01-JAN-2019' - 60) = 1 mon 29 days` Zum Erreichen der gleichen Werte wie die Oracle-Funktion `MONTH_BETWEEN` ist eine spezifischere Konversion 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`	Ja	`To_CHAR`	Entsprechung zu Oracle: `TO_CHAR(CURRENT_TIMESTAMP,'DD-MM-YYYY HH24:MI:SS'); 01-01-2019 10:01:01`

Codierungs- und Decodierungsfunktionen

Oracle-Funktion	Oracle-Funktionsspezifikation oder -Implementierung	Cloud SQL for PostgreSQL-Äquivalent	Entsprechende Cloud SQL for PostgreSQL-Funktion	Funktionsspezifikation oder -Implementierung von Cloud SQL for PostgreSQL
`DECODE`	Vergleicht den Ausdruck anhand einer `IF-THEN-ELSE`-Anweisung einzeln mit jedem Suchwert.	Nein	`CASE`	Verwenden Sie die Cloud SQL für PostgreSQL-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 des Ausdrucks enthält.	Nein	–	Nicht unterstützt.
`ORA_HASH`	Berechnet einen Hashwert für einen bestimmten Ausdruck.	Nein	`MD5 / SHA224 / SHA256 / SHA385 / SHA512`	Verwenden Sie die `MD5`-Funktion von Cloud SQL for PostgreSQL für 128-Bit-Prüfsummen oder die Funktion `SHA` für 160-Bit- Prüfsummen, um Hashwerte zu generieren.

Umrechnungsfunktionen

Oracle-Funktion	Oracle-Funktionsspezifikation oder -Implementierung	Cloud SQL for PostgreSQL-Äquivalent	Entsprechende Cloud SQL for PostgreSQL-Funktion	Funktionsspezifikation oder -Implementierung von Cloud SQL for PostgreSQL
`CAST`	Konvertiert einen integrierten Datentyp oder Sammlungstypwert in einen anderen integrierten Datentyp oder Sammlungstypwert: `CAST('1' as int) + 1 = 2`	Teilweise	`CAST`	Die Cloud SQL for PostgreSQL `CAST`-Funktion ähnelt der Oracle `CAST` -Funktionalität. In bestimmten Fällen muss sie jedoch aufgrund von Datentypunterschieden zwischen den beiden Datenbanken angepasst werden: `CAST('1' as int) + 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 PostgreSQL gibt einen `bytea`-Wert zurück. Dieser ist ein binärer String anstelle von `VARCHAR` oder `TEXT`. Die von PostgreSQL unterstützten Zeichensätze unterscheiden sich auch von Oracle. `CONVERT('Ä Ê Í Õ Ø A B C D E', 'UTF8', 'LATIN1') = [Binary representation of the string in LATIN1 encoding]`
`TO_CHAR` (String/Zahl)	Die Funktion konvertiert eine Zahl oder ein Datum in einen String: `TO_CHAR(22.73,'$99.9') = $22.7`	Teilweise	`TO_CHAR`	Die Funktion `TO_CHAR` von Cloud SQL for PostgreSQL ähnelt der Oracle-Funktion. Cloud SQL for PostgreSQL unterstützt eine etwas andere Liste von Formatierungsstrings. Standardmäßig reserviert Cloud SQL for PostgreSQL eine Spalte für das Vorzeichen, daher steht ein Leerzeichen vor positiven Zahlen. Dies kann unterdrückt werden, indem das `FM`-Präfix verwendet wird: `TO_CHAR(22.73,'FM$99.9') = $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	`TO_DATE`	Die Funktion `TO_DATE` von Cloud SQL for PostgreSQL ähnelt der Oracle-Funktion. Cloud SQL for PostgreSQL unterstützt eine etwas andere Liste von Formatierungsstrings: `TO_DATE('2019/01/01', 'yyyy-mm-dd') = 2019-01-01`
`TO_NUMBER`	Wandelt den Ausdruck in einen Wert des Datentyps `NUMBER` um: `TO_NUMBER('01234') = 1234`	Teilweise	`TO_NUMBER`	Für die `TO_NUMBER`-Funktion von Cloud SQL for PostgreSQL ist ein Formatierungsstring als Eingabe erforderlich, während das in Oracle optional ist: `TO_NUMBER('01234','99999') = 1234` Alternativ können Sie die `CAST`-Funktion für Konvertierungen verwenden, für die keine komplexen Formatierungsstrings erforderlich sind: `CAST('01234' AS NUMERIC) = 1234`

Bedingte SELECT-Funktionen

Oracle-Funktion	Oracle-Funktionsspezifikation oder -Implementierung	Cloud SQL for PostgreSQL-Äquivalent	Entsprechende Cloud SQL for PostgreSQL-Funktion	Funktionsspezifikation oder -Implementierung von Cloud SQL for PostgreSQL
`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`	Entsprechung zu Oracle: `CASE WHEN condition THEN result [WHEN ...] [ELSE result] END`

Nullfunktionen

Oracle-Funktion	Oracle-Funktionsspezifikation oder -Implementierung	Cloud SQL for PostgreSQL-Äquivalent	Entsprechende Cloud SQL for PostgreSQL-Funktion	Funktionsspezifikation oder -Implementierung von Cloud SQL for PostgreSQL
`COALESCE`	Gibt den ersten Nicht-Null-Ausdruck in der Ausdrucksliste zurück: `COALESCE(null, '1', 'a') = a`	Ja	`COALESCE`	Entsprechung zu Oracle: `COALESCE(null, '1', 'a') = 1`
`NULLIF`	Vergleicht expr1 und expr2. 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') = 1`	Ja	`NULLIF`	Entsprechung zu Oracle: `NULLIF('1', '2') = 1`
`NVL`	Ersetzt null (als Leerzeichen zurückgegeben) durch einen String in den Ergebnissen einer Abfrage: `NVL(null, 'a') = a`	Nein	`COALESCE`	Verwenden Sie alternativ die `COALESCE`-Funktion: `COALESCE(null, 'a') = a`
`NVL2`	Bestimmt den von einer Abfrage zurückgegebenen Wert anhand der Tatsache, ob ein angegebener Ausdruck null ist oder nicht.	Nein	`COALESCE`	Verwenden Sie alternativ die Funktion `COALESCE`: `COALESCE(null, 1, 'a') = 1`

Umgebungs- und Kennungsfunktionen

Oracle-Funktion	Oracle-Funktionsspezifikation oder -Implementierung	Cloud SQL for PostgreSQL-Äquivalent	Entsprechende Cloud SQL for PostgreSQL-Funktion	Funktionsspezifikation oder -Implementierung von Cloud SQL for PostgreSQL
`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`	Teilweise mit einem anderen Funktionsnamen und einer anderen Formatierung	`UUID_GENERATE_V4`	Cloud SQL for PostgreSQL unterstützt die uuid-ossp-Erweiterung, die eine Liste mit UUID-Generierungsfunktionen wie `UUID_GENERATE_V4` bereitstellt: `SELECT UUID_GENERATE_v4()` = eaf356a6-2847-478d-af3b-6883f5ac6af2
`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`	Ja	`USER`	Entsprechung zu Oracle: `SELECT USER; = postgres`
`USERENV`	Gibt Informationen zur aktuellen Nutzersitzung mit der aktuellen Parameterkonfiguration zurück: `SELECT USERENV('LANGUAGE') FROM DUAL = ENGLISH_AMERICA.AL32UTF8`	Nein	–	In Cloud SQL for PostgreSQL ist zwar keine äquivalente `USERENV`-Funktion vorhanden, einzelne Parameter wie `USERENV('SID')` können aber auch mithilfe von Systeminformationsfunktionen wie `PG_BACKGROUND_PID()` abgerufen werden.
`ROWID`	Der Oracle-Server weist jeder Zeile in jeder 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 mit einem anderen Funktionsnamen	`ctid`	`ctid` in Cloud SQL for PostgreSQL identifiziert den physischen Standort der Zeilenversion innerhalb ihrer Tabelle, was der `ROWID` von Oracle ähnelt.
`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	`LIMIT or ROW_NUMBER()`	Anstatt die Anzahl der Ergebnisse zu begrenzen, die von Abfragen mit `ROWNUM` zurückgegeben werden, unterstützt Cloud SQL for PostgreSQL das Verwenden von `LIMIT` und `OFFSET` für ähnliche Zwecke. Die `ROW_NUMBER()` Fensterfunktion kann in anderen Szenarien als Problemumgehungsersatz für den Oracle-`ROWNUM` verwendet werden. Allerdings muss die Ergebnisreihenfolge und Leistungsdeltas berücksichtigt werden, bevor sie als Ersatz verwendet werden kann.

Aggregatfunktionen (Gruppenfunktionen)

Oracle-Funktion	Oracle-Funktionsspezifikation oder -Implementierung	Cloud SQL for PostgreSQL-Äquivalent	Entsprechende Cloud SQL for PostgreSQL-Funktion	Funktionsspezifikation oder -Implementierung von Cloud SQL for PostgreSQL
`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 der Werte der Spalte oder des 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	`STRING_AGG`	Verwenden Sie die `STRING_AGG`-Funktion von Cloud SQL for PostgreSQL, um ähnliche Ergebnisse wie Oracle zurückzugeben. Gehen Sie in bestimmten Fällen von Syntaxunterschieden aus: `SELECT STRING_AGG(DEPARTMENT_NAME, ', ' order by DEPARTMENT_NAME) FROM DEPARTMENTS; -- Single line results = Accounting, Administration, Benefits, Construction`

Oracle 12c Fetch

Oracle-Funktion	Oracle-Funktionsspezifikation oder -Implementierung	Cloud SQL for PostgreSQL-Äquivalent	Entsprechende Cloud SQL for PostgreSQL-Funktion	Funktionsspezifikation oder -Implementierung von Cloud SQL for PostgreSQL
`FETCH`	Ruft Datenzeilen aus der Ergebnismenge einer mehrzeiligen Abfrage ab: `SELECT * FROM EMPLOYEES FETCH FIRST 10 ROWS ONLY;`	Nein	LIMIT	Verwenden Sie die Cloud SQL for PostgreSQL-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 Cloud SQL for PostgreSQL-Formate unterschiedliche Standardergebnisse zurückgeben:

Die Oracle-Funktion SYSDATE gibt standardmäßig 01-AUG-19 zurück.
Die PostgreSQL-CURRENT_DATE-Funktion gibt standardmäßig 2019-08-01 zurück (keine Tageszeit, auch bei Formatierung). Verwenden Sie zum Abrufen des aktuellen Datums und der Uhrzeit die Funktion CURRENT_TIMESTAMP, die standardmäßig 2019-08-01 00:00:00.000000+00 zurückgibt.
Datums- und Uhrzeitformate können mit den Cloud SQL for PostgreSQL-TO_CHAR-Funktionen festgelegt werden.

Oracle-Funktion oder -Unterabfrage	Cloud SQL for PostgreSQL-Äquivalent	Entsprechende Funktion oder Unterabfrage für Cloud SQL for PostgreSQL	Funktionsspezifikation oder -Implementierung von Cloud SQL for PostgreSQL
`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 PostgreSQL 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	Cloud SQL for PostgreSQL unterstützt alle grundlegenden Operatoren: `> \| >= \| < \| <= \| = \| <> \| !=`

Analysefunktionen (oder Fenster- und Rankingfunktionen)

Die Analysefunktionen von Oracle erweitern die Funktionalität von Standard-SQL-Vorgängen, indem sie die Möglichkeit bieten, Aggregatwerte für eine Gruppe von Zeilen zu berechnen (z. B. RANK(), ROW_NUMBER(), FIRST_VALUE()). Diese Funktionen werden auf logisch partitionierte Datensätze im Bereich eines einzelnen Abfrageausdrucks angewendet. Sie werden häufig in Data-Warehouse-Prozessen in Verbindung mit Business-Intelligence-Berichten und -Analysen verwendet.

Konvertierungshinweise

Cloud SQL for PostgreSQL unterstützt viele Analysefunktionen, die in Postgres als Aggregatfunktionen und Fensterfunktionen bezeichnet werden. Wenn Ihre Anwendung eine weniger gängige Funktion verwendet, die in Postgres nicht unterstützt wird, müssen Sie nach einer unterstützten Erweiterung suchen oder die Logik in die Anwendungsschicht verschieben.

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

Funktionsfamilie	Ähnliche Funktionen	Von Cloud SQL for PostgreSQL unterstützt
Analyse und Ranking	`RANK AVERAGE_RANK DENSE_RANK ROW_NUMBER PERCENT_RANK CUME_DIST NTILE FIRST_VALUE LAST_VALUE OVER (PARTITION BY...)`	Ja (außer `AVERAGE_RANK`)
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`	Ja (nur `LAG` und `LEAD`)

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. CTEs werden sowohl von Oracle als auch von Cloud SQL for PostgreSQL unterstützt.

Beispiele

Oracle und Cloud SQL for PostgreSQL
`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;`

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

Cloud SQL for PostgreSQL unterstützt nicht die Funktionalität MERGE, im Gegensatz zu Oracle. Zur teilweisen Simulation der MERGE-Funktionalität stellt Cloud SQL for PostgreSQL die INSERT ... ON CONFLICT DO UPDATE-Anweisungen bereit:

INSERT… ON CONFLICT DO UPDATE: Wenn eine eingefügte Zeile einen eindeutigen Verstoß oder einen Ausschluss Einschränkung Verstoß Fehler verursacht, wird die in der ON CONFLICT DO UPDATE-Klausel angegebene alternative Aktion ausgeführt. Beispiel:

INSERT INTO tbl (a,b,c) VALUES (1,2,3)
  ON CONFLICT (a) DO UPDATE SET b = 2, c = 3;

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 beeinflussen können, um effizientere Abfrageausführungspläne zu erstellen. Cloud SQL for PostgreSQL bietet keinen vergleichbaren Mechanismus auf SQL-Anweisungsebene mit Hinweisen um das Optimierungstool zu beeinflussen.

Um die vom Abfrageplaner ausgewählten Abfragepläne zu beeinflussen, bietet Cloud SQL for PostgreSQL eine Reihe von Konfigurationsparametern, die auf Sitzungsebene angewendet werden können. Die Auswirkungen dieser Konfigurationsparameter reichen von der Aktivierung/Deaktivierung einer bestimmten Zugriffsmethode bis zur Anpassung der Kostenkonstanten des Planers. Die folgende Anweisung deaktiviert beispielsweise die Verwendung von sequenziellen Scanplantypen wie vollständigen Tabellenscans durch den Abfrageplaner:

SET ENABLE_SEQSCAN=FALSE;

Verwenden Sie die folgende Anweisung, um die Kostenschätzung des Planers für einen Abruf einer zufälligen Laufwerksseite anzupassen (Standard: 4,0):

SET RANDOM_PAGE_COST=2.0;

Durch die Reduzierung dieses Wertes bevorzugt Cloud SQL for PostgreSQL Indexscans. Wenn er vergrößert wird, wird das Gegenteil erreicht.

Konvertierungshinweise

Da es grundlegende Unterschiede zwischen den Optimierungen von Oracle und Cloud SQL for PostgreSQL gibt und Cloud SQL for PostgreSQL keine SQL-Abfragehinweise im Oracle-Stil unterstützt, sollten Sie alle Abfragehinweise während der Migration zu Cloud SQL for PostgreSQL entfernen. Führen Sie dann strenge Leistungstests über Cloud SQL for PostgreSQL-Tools durch, untersuchen Sie Abfragen mit Ausführungsplänen und passen Sie die Instanz- oder Sitzungsparameter gemäß Anwendungsfall an.

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. Sie sind besonders nützlich, wenn Sie die Leistungsoptimierung von Abfragen vornehmen müssen, um beispielsweise die Indexleistung zu ermitteln oder festzustellen, ob fehlende Indexe vorhanden sind, 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. Stattdessen handelt es sich um ein Tool, mit dem Sie Leistungsunterschiede zwischen Oracle und Cloud SQL for PostgreSQL analysieren können, die dieselbe Anweisung für identische Datensätze ausführen.

Cloud SQL for PostgreSQL unterstützt nicht die gleiche Syntax, Funktionalität oder Ausgabe des Ausführungsplans wie Oracle.

Hier ein Beispiel für einen Ausführungsplan:

Oracle-Ausführungsplan Ausführungsplan für Cloud SQL for PostgreSQL

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 | --------------------------------------------------------------------------------------------- postgres=> EXPLAIN SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 105; QUERY PLAN -------------------------------------------------------------------------------- Index Scan using emp_emp_id_pk on employees (cost=0.14..8.16 rows=1 width=71) Index Cond: (employee_id = '105'::numeric) (2 rows)

Oracle-Ausführungsplan	Ausführungsplan für Cloud SQL for PostgreSQL
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 \| ---------------------------------------------------------------------------------------------	`postgres=> EXPLAIN SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 105; QUERY PLAN -------------------------------------------------------------------------------- Index Scan using emp_emp_id_pk on employees (cost=0.14..8.16 rows=1 width=71) Index Cond: (employee_id = '105'::numeric) (2 rows)`

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 und die prozedurale Programmiersprache MySQL für MySQL. PL/pgSQL ist für die erweiterte prozedurale Programmiersprache von PostgreSQL vorgesehen.

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 PL/SQL zu PL/pgSQL

Aus Sicht der Migration von Oracle PL/SQL zu Cloud SQL for PostgreSQL ähnelt PL/pgSQL der Struktur und Syntax von Oracle PL/SQL. Es gibt jedoch einige wichtige Unterschiede, die eine Codemigration erfordern. Datentypen unterscheiden sich beispielsweise zwischen Oracle und Cloud SQL for PostgreSQL. Eine Übersetzung ist oft erforderlich, um sicherzustellen, dass der migrierte Code die entsprechenden Datentypnamen verwendet, die von Cloud SQL for PostgreSQL unterstützt werden. Ausführliche Informationen zu den Unterschieden zwischen den beiden Sprachen finden Sie unter Portierung von Oracle PL/SQL.

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 PostgreSQL muss der Nutzer die Berechtigung USAGE haben, um eine Codeprozedur oder Funktion zu erstellen. Zum Ausführen einer Prozedur oder Funktion muss der Nutzer die Berechtigung EXECUTE für die Prozedur oder Funktion haben.

Standardmäßig ist eine PL/pgSQL-Verfahren oder -Funktion als SECURITY INVOKER definiert, d. h. das Verfahren oder die Funktion wird mit den Berechtigungen des Nutzers ausgeführt, der es aufruft. Alternativ könnte SECURITY DEFINER angegeben werden, damit die Funktion mit den Berechtigungen des Nutzers ausgeführt wird, dem sie gehört.

Cloud SQL for PostgreSQL gespeicherte Prozedur- und Funktionssyntax

Das folgende Beispiel zeigt die gespeicherte Verfahren und Funktionssyntax von Cloud SQL for PostgreSQL:

CREATE [ OR REPLACE ] PROCEDURE
    name ( [ [ argmode ] [ argname ] argtype [ { DEFAULT | = } default_expr ] [, ...] ] )
  { LANGUAGE lang_name
    | TRANSFORM { FOR TYPE type_name } [, ... ]
    | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
    | SET configuration_parameter { TO value | = value | FROM CURRENT }
    | AS 'definition'
    | AS 'obj_file', 'link_symbol'
  } ...

CREATE [ OR REPLACE ] FUNCTION
    name ( [ [ argmode ] [ argname ] argtype [ { DEFAULT | = } default_expr ] [, ...] ] )
    [ RETURNS rettype
      | RETURNS TABLE ( column_name column_type [, ...] ) ]
  { LANGUAGE lang_name
    | TRANSFORM { FOR TYPE type_name } [, ... ]
    | WINDOW
    | IMMUTABLE | STABLE | VOLATILE | [ NOT ] LEAKPROOF
    | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
    | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
    | PARALLEL { UNSAFE | RESTRICTED | SAFE }
    | COST execution_cost
    | ROWS result_rows
    | SUPPORT support_function
    | SET configuration_parameter { TO value | = value | FROM CURRENT }
    | AS 'definition'
    | AS 'obj_file', 'link_symbol'
  } ...

Trigger

Ein Trigger ist eine gespeicherte Prozedur, die ausgelöst wird, wenn ein bestimmtes Ereignis auftritt. In Oracle ist das auslösende Ereignis entweder mit einer Tabelle, einer Ansicht, einem Schema oder der Datenbank verknüpft. Zu den auslösenden Ereignissen gehören:

Anweisungen der Datenbearbeitungssprache (Data Manipulation Language, DML) (z. B. INSERT, UPDATE, DELETE)
DDL-Anweisungen (Data Definition Language, Datendefinitionssprache), z. B. CREATE, ALTER, DROP
Datenbankereignisse (z. B. LOGON, STARTUP, SHUTDOWN)

Folgende Oracle-Triggertypen sind zulässig:

Einfacher Trigger: Wird genau einmal ausgelöst, entweder vor oder nach dem angegebenen auslösenden Ereignis
Zusammengesetzter Trigger: Bei mehreren Ereignissen ausgelöst
INSTEAD OF-Trigger: Eine spezielle Art von DML-Trigger zum Bieten eines transparenten Aktualisierungsmechanismus für komplexe, nicht bearbeitbare Ansichten
Systemtrigger: Wird bei bestimmten Datenbankereignissen ausgelöst

In Cloud SQL for PostgreSQL wird vor oder nach einem DML-Vorgang für eine bestimmte Tabelle, Ansicht oder externe Tabelle ein Trigger ausgelöst. Der Trigger INSTEAD OF wird unterstützt, um einen Aktualisierungsmechanismus für Ansichten bereitzustellen. Ein Trigger für DDL-Vorgänge wird als Ereignistrigger bezeichnet. Cloud SQL for PostgreSQL unterstützt keine Systemtrigger von Oracle basierend auf Datenbankereignissen.

Im Gegensatz zu Oracle-Triggern unterstützen Cloud SQL for PostgreSQL-Trigger keine Verwendung eines anonymen PL/pgSQL-Blocks als Triggertext. Eine benannte Funktion, die null oder mehr Argumente annimmt und einen Typtrigger zurückgibt, muss in der Triggerdeklaration angegeben werden. Diese Funktion wird ausgeführt, wenn der Trigger ausgelöst wird.

Cloud SQL for PostgreSQL-Trigger- und Ereignistrigger-Syntax

Das folgende Beispiel zeigt die Syntax für Trigger und Ereignistrigger von Cloud SQL for PostgreSQL:

CREATE [ CONSTRAINT ] TRIGGER name { BEFORE | AFTER | INSTEAD OF } { event [ OR ... ] }
    ON table_name
    [ FROM referenced_table_name ]
    [ NOT DEFERRABLE | [ DEFERRABLE ] [ INITIALLY IMMEDIATE | INITIALLY DEFERRED ] ]
    [ REFERENCING { { OLD | NEW } TABLE [ AS ] transition_relation_name } [ ... ] ]
    [ FOR [ EACH ] { ROW | STATEMENT } ]
    [ WHEN ( condition ) ]
    EXECUTE { FUNCTION | PROCEDURE } function_name ( arguments )

event kann einer der folgenden Werte sein: INSERT, UPDATE [ OF column_name [, ... ] ], DELETE, TRUNCATE.

CREATE EVENT TRIGGER name
    ON event
    [ WHEN filter_value IN (filter_value [, ... ]) [ AND ... ] ]
    EXECUTE { FUNCTION | PROCEDURE } function_name()

event kann einer der folgenden Werte sein: ddl_command_start, ddl_command_end, table_rewrite, sql_drop.

Für filter_value ist nur der Wert TAG zulässig.

filter_value kann eines der unterstützten Befehls-Tags sein.

Nächste Schritte

Mehr über Cloud SQL for PostgreSQL-Nutzerkonten erfahren.
Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center