Migrazione degli utenti Oracle® a Cloud SQL per PostgreSQL: query, stored procedure, funzioni e trigger

Questo documento fa parte di una serie che fornisce informazioni e indicazioni chiave relative alla pianificazione e all'esecuzione di migrazioni dei database Oracle® 11g/12c verso Cloud SQL per PostgreSQL alla versione 12. Oltre alla parte introduttiva sulla configurazione, la serie include le seguenti parti:

Query

Oracle e Cloud SQL per PostgreSQL supportano lo standard ANSI SQL. Pertanto, in genere è semplice eseguire la migrazione delle istruzioni SQL utilizzando solo elementi di sintassi di base (ad esempio, non specificando funzioni scalari o altre funzionalità estese di Oracle). La sezione seguente illustra gli elementi di query Oracle comuni e gli equivalenti Cloud SQL per PostgreSQL corrispondenti.

Sintassi SELECT e FROM di base

Nome della funzionalità o nome sintassi Oracle Panoramica o implementazione di Oracle Assistenza Cloud SQL per PostgreSQL Soluzione corrispondente o alternativa Cloud SQL per PostgreSQL
Sintassi di base di SQL per il recupero dei dati SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY 		Sì SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY
SELECT
per la stampa dell'output		 SELECT 1 FROM DUAL Sì SELECT 1
Alias di colonna SELECT COL1 AS C1 Sì SELECT COL1 AS C1
OR
SELECT COL1 C1
Distinzione tra maiuscole e minuscole per i nomi delle tabelle Nessuna distinzione tra maiuscole e minuscole
(ad esempio, il nome della tabella può essere orders e/o ORDERS).		 Sì I nomi non fanno distinzione tra maiuscole e minuscole, a meno che non siano tra virgolette (ad esempio, orders e ORDERS sono considerati uguali, mentre "orders" e "ORDERS" sono trattati in modo diverso).

Per maggiori dettagli sulla sintassi SELECT di Cloud SQL per PostgreSQL, consulta documentazione.

Visualizzazioni in linea

  • Le visualizzazioni in linea (note anche come tabelle derivate) sono istruzioni SELECT , situate nella clausola FROM e utilizzate come sottoquery.
  • Le visualizzazioni in linea possono semplificare le query complesse rimuovendo calcoli composti o eliminazione delle operazioni di join, durante la condensazione diverse query separate in un'unica query semplificata.
  • Nota di conversione: le visualizzazioni in linea Oracle non richiedono l'utilizzo di alias, mentre Cloud SQL per PostgreSQL richiede alias di ogni visualizzazione in linea.

La tabella seguente mostra un esempio di conversione da Oracle a Cloud SQL per PostgreSQL, come visualizzazione in linea.

Oracle 11g/12c Cloud SQL per PostgreSQL 12
SQL> SELECT FIRST_NAME,
DEPARTMENT_ID,
SALARY,
DATE_COL
FROM EMPLOYEES,
(SELECT SYSDATE AS DATE_COL FROM DUAL);

L'output è simile al seguente:

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

Senza alias per la visualizzazione in linea:

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.

Aggiunta di un alias alla visualizzazione in linea:

postgres=> SELECT FIRST_NAME,
postgres-> DEPARTMENT_ID,
postgres-> SALARY,
postgres-> DATE_COL
postgres-> FROM EMPLOYEES, (SELECT NOW() AS DATE_COL) AS C1;

L'output è simile al seguente:

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

Istruzioni JOIN

Le istruzioni Oracle JOIN sono supportate da Cloud SQL per PostgreSQL JOIN istruzioni. Tuttavia, l'utilizzo dell'operatore di join Oracle (+) non è supportato da Cloud SQL per PostgreSQL. Per ottenere lo stesso risultato, devi convertire alla sintassi SQL standard per i join esterni.

La seguente tabella mostra un esempio di conversione JOIN.

Tipo di JOIN Oracle Supportato da Cloud SQL per PostgreSQL Sintassi JOIN di Cloud SQL per PostgreSQL
INNER JOIN Sì SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
CROSS JOIN Sì SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E CROSS JOIN DEPARTMENTS D;
FULL JOIN [ OUTER ] Sì SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E FULL JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
LEFT JOIN [ OUTER ] Sì SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E LEFT JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
RIGHT JOIN [ OUTER ] Sì SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E RIGHT JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
SUBQUERY Sì 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, INTERSETT e MENO

Cloud SQL per PostgreSQL supporta Oracle UNION, UNION ALL e Operatori INTERSECT. L'operatore MINUS non è supportato. Tuttavia, Cloud SQL per PostgreSQL implementa l'operatore EXCEPT, che è equivalente all'operatore MINUS in Oracle. Inoltre, Cloud SQL per PostgreSQL supporta gli operatori INTERSECT ALL e EXCEPT ALL che non sono supportati da Oracle.

  • UNION: allega gli insiemi di risultati di due o più istruzioni SELECT ed elimina i record duplicati.
  • UNION ALL: allega gli insiemi di risultati di due o più istruzioni SELECT senza eliminare i record duplicati.
  • INTERSECT: restituisce l'intersezione di due o più istruzioni SELECT solo se esiste un record in entrambi i set di dati. I record duplicati non vengono eliminati.
  • INTERSECT ALL (solo Cloud SQL per PostgreSQL): restituisce il valore intersezione di due o più istruzioni SELECT solo se esiste un record in entrambi i set di dati.
  • MINUS (EXCEPT in Cloud SQL per PostgreSQL): ne confronta due o più Istruzioni SELECT, che restituiscono solo righe distinte dalla prima query che non vengono restituiti dalle altre istruzioni.
  • EXCEPT ALL (solo Cloud SQL per PostgreSQL): confronta due o più istruzioni SELECT, restituendo solo le righe della prima query che non vengono restituite dalle altre istruzioni senza eliminare i record duplicati.

Note sulle conversioni

Quando esegui la conversione dagli operatori MINUS di Oracle in Cloud SQL per PostgreSQL, utilizza gli operatori EXCEPT.

Esempi

Funzione Oracle Implementazione Oracle Assistenza Cloud SQL per PostgreSQL Soluzione corrispondente o alternativa di Cloud SQL per PostgreSQL
UNION SELECT COL1 FROM TBL1
UNION
SELECT COL1 FROM TBL2 		Sì SELECT COL1 FROM TBL1
UNION
SELECT COL1 FROM TBL2
UNION ALL SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2 		Sì SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2
INTERSECT SELECT COL1 FROM TBL1
INTERSECT
SELECT COL1 FROM TBL2 		Sì SELECT COL1 FROM TBL1
INTERSECT
SELECT COL1 FROM TBL2
MINUS SELECT COL1 FROM TBL1
MINUS
SELECT COL1 FROM TBL2 		Sì (da Convert MINUS a EXCEPT in PostgreSQL) SELECT COL1 FROM TBL1
EXCEPT
SELECT COL1 FROM TBL2

Funzioni scalari (riga singola) e di gruppo

Cloud SQL per PostgreSQL fornisce un ampio elenco di scalari (riga singola) e funzioni di aggregazione. Alcune funzioni di Cloud SQL per PostgreSQL in modo simile alle controparti Oracle (per nome e funzionalità o in base a un nome diverso ma con funzionalità simili). Sebbene Le funzioni di Cloud SQL per PostgreSQL possono avere nomi identici a quelli controparti, a volte presentano funzionalità diverse.

Le tabelle seguenti descrivono dove Oracle e Cloud SQL per PostgreSQL sono equivalenti per nome e funzionalità (specificato da "Sì") e dove è consigliata una conversione (tutti i casi diversi da "Sì").

Funzioni di carattere
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL o la specifica della funzione Cloud SQL per PostgreSQL implementazione
CONCAT Restituisce str1 concatenato con str2:

CONCAT('A', 1) = A1 		Sì CONCAT Equivalente a Oracle:

CONCAT('A', 1) = A1
LOWER/UPPER Restituisce char, con tutte le lettere minuscole o maiuscole:

LOWER('SQL') = sql 		Sì LOWER/UPPER Equivalente a Oracle:

LOWER('SQL') = sql
LPAD/RPAD Restituisce expr1, riempito a sinistra o a destra fino alla lunghezza n con la sequenza di caratteri in expr2:

LPAD('A',3,'*') = **A 		Sì LPAD/RPAD Equivalente a Oracle:

LPAD('A',3,'*') = **A
SUBSTR Restituisce una parte di char, a partire dalla posizione del carattere, con una lunghezza pari a
caratteri della sottostringa:

SUBSTR('PostgreSQL', 8, 3)
= SQL 		Parzialmente SUBSTR Equivale a Oracle quando la posizione iniziale è un numero positivo.

SUBSTR('PostgreSQL', 8, 3)
= SQL
Quando in Oracle viene fornito un numero negativo come posizione iniziale, viene eseguita un'operazione di sottostringa dalla fine della stringa, diversamente da Cloud SQL per PostgreSQL. Utilizza la funzione RIGHT come sostituto se vuoi il comportamento di Oracle.
INSTR Restituisce la posizione (indice) di una stringa specifica da una determinata stringa:

INSTR('PostgreSQL', 'e')
= 7 		No N/D Cloud SQL per PostgreSQL non ha un oggetto instr integrato personalizzata. Una funzione instr compatibile con Oracle potrebbe essere implementata utilizzando PL/pgSQL.
REPLACE Restituisce il carattere con ogni occorrenza di una stringa di ricerca sostituita da una
stringa sostitutiva:

REPLACE('ORADB', 'ORA', 'PostgreSQL')
= PostgreSQLDB 		Parzialmente REPLACE Il parametro di stringa sostitutivo è facoltativo in Oracle, mentre in Cloud SQL per PostgreSQL. Se il parametro viene omesso, Oracle rimuove tutte le occorrenze delle stringhe di ricerca. Lo stesso comportamento potrebbe essere ottenuto in Cloud SQL per PostgreSQL fornendo una stringa vuota come stringa sostitutiva.

REPLACE('ORADB', 'ORA', 'PostgreSQL')
= PostgreSQLDB
TRIM Taglia i caratteri iniziali e finali (o entrambi) da una stringa:

TRIM(both '-' FROM '-PostgreSQL-')
= PostgreSQL
TRIM(' PostgreSQL ')
= PostgreSQL 		Sì TRIM Equivalente a Oracle:

TRIM(both '-' FROM '-PostgreSQL-')
= PostgreSQL
TRIM(' PostgreSQL ')
= PostgreSQL
LTRIM/RTRIM Rimuove dall'estremità sinistra o destra della stringa tutti i caratteri che
vengono visualizzati nella ricerca:

LTRIM(' PostgreSQL', ' ')
= PostgreSQL 		Sì LTRIM/RTRIM Equivalente a Oracle:

LTRIM(' PostgreSQL', ' ') = PostgreSQL
ASCII Restituisce la rappresentazione decimale nel set di caratteri del database della primo carattere di carattere:

ASCII('A') = 65 		Sì ASCII Equivalente a Oracle:

ASCII('A') = 65
CHR Restituisce il valore del codice ASCII, che è un valore numerico compreso tra 0 e 225, in un carattere:

CHR(65) = A 		Sì CHAR Equivalente a Oracle:

CHR(65) = A
LENGTH Restituisce la lunghezza di una determinata stringa:

LENGTH ('PostgreSQL') = 10 		Sì LENGTH Equivalente a Oracle:

LENGTH ('PostgreSQL') = 10
REGEXP_REPLACE Cerca un pattern di espressioni regolari in una stringa:

REGEXP_REPLACE('John', '[hn].', '1') = Jo1 		Sì REGEXP_REPLACE Equivalente a Oracle:

REGEXP_REPLACE('John', '[hn].', '1') = Jo1
REGEXP_SUBSTR Estende la funzionalità della funzione SOSTIITUI cercando un pattern di espressione regolare in una
stringa:

REGEXP_SUBSTR('https://console.cloud.google.com/sql/instances','https://([[:alnum:]]+\.?){3,4}/?')
= https://console.cloud.google.com/ 		No N/D Utilizza REGEXP_MATCH di PostgreSQL per ottenere risultati simili le funzionalità di machine learning.
REGEXP_COUNT Restituisce il numero di volte in cui un pattern si verifica in una stringa di origine. No N/D Utilizza REGEXP_MATCH di PostgreSQL per ottenere funzionalità simili.
REGEXP_INSTR Cerca una posizione stringa (indice) per un
regolare di espressione di base.		 No N/D Converti la funzionalità nel livello di applicazione.
REVERSE Restituisce una stringa invertita.

REVERSE('PostgreSQL') = LQSergtsoP 		Sì REVERSE Equivalente a Oracle:

REVERSE('PostgreSQL') = LQSergtsoP
Funzioni numeriche
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL Implementazione o specifica della funzione Cloud SQL per PostgreSQL
ABS Valore assoluto di n:

ABS(-4.6) = 4.6 		Sì ABS Equivalente a Oracle:

ABS(-4.6) = 4.6
CEIL Restituisce il numero intero più piccolo maggiore o uguale a n:

CEIL(21.4) = 22 		Sì CEIL Equivalente a Oracle:

CEIL(21.4) = 22
FLOOR Restituisce il numero intero più grande uguale o minore di n:

FLOOR(-23.7) = -24 		Sì FLOOR Equivalente a Oracle:

FLOOR(-23.7) = -24
MOD Restituisce il resto di m diviso per n:

MOD(10, 3) = 1 		Sì MOD Equivalente a Oracle:

MOD(10, 3) = 1
ROUND Restituisce n arrotondato a numeri interi a destra della virgola decimale:

ROUND(1.39, 1) = 1.4 		Sì ROUND Equivalente a Oracle:

ROUND(1.39, 1) = 1.4
TRUNC
(numero)		 Restituisce n1 troncato a n2 cifre decimali:

TRUNC(99.999) = 99
TRUNC(99.999, 0) = 99 		Sì TRUNCATE
(numero)		 Equivalente a Oracle:

TRUNC(99.999) = 99
TRUNC(99.999, 0) = 99
Funzioni DateTime
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL o la specifica della funzione Cloud SQL per PostgreSQL implementazione
SYSDATE Restituisce la data e l'ora correnti impostate per il sistema operativo su cui del server di database:

SELECT SYSDATE FROM DUAL
= 31-JUL-2019 		Parzialmente con nome e formattazione della funzione diversi CURRENT_TIMESTAMP CURRENT_TIMESTAMP restituirà un formato data/ora diverso rispetto alla funzione SYSDATE di Oracle:

SELECT CURRENT_TIMESTAMP
= 2019-07-31 06:46:40.171477+00
SYSTIMESTAMP Restituisce la data di sistema, inclusi i secondi frazionari e il fuso orario:

SELECT SYSTIMESTAMP FROM DUAL
= 01-JAN-19 07.37.11.622187000 AM +00:00 		Parzialmente con nome funzione diverso CURRENT_TIMESTAMP Cloud SQL per PostgreSQL restituisce un formato di data/ora diverso rispetto a Oracle La formattazione della data è obbligatoria per fare in modo che corrisponda ai formati della data/dell'ora originali:

SELECT CURRENT_TIMESTAMP
= 2019-01-31 07:37:11.622187+00
LOCAL TIMESTAMP Restituisce la data e l'ora correnti nel fuso orario della sessione in un valore del tipo di dati TIMESTAMP:

SELECT LOCALTIMESTAMP FROM DUAL
= 01-JAN-19 10.01.10.123456 PM 		Parzialmente con formattazione di data/ora diversa LOCAL TIMESTAMP Cloud SQL per PostgreSQL restituisce un formato data/ora diverso da quello di Oracle. La formattazione della data deve corrispondere a quella della data e dell'ora originale formato:

SELECT LOCALTIMESTAMP
= 2019-01-31 07:37:11.622187+00
CURRENT_DATE Restituisce la data corrente nel fuso orario della sessione:

SELECT CURRENT_DATE FROM DUAL
= 31-JAN-19 		Parzialmente con formattazione di data/ora diversa CURRENT_ DATE Cloud SQL per PostgreSQL restituisce un formato data/ora diverso da Oracle. Data deve corrispondere al formato originale di data e ora:

SELECT CURRENT_DATE
= 2019-01-31
CURRENT_TIMESTAMP Restituisce la data e l'ora correnti nel fuso orario della sessione:

SELECT CURRENT_TIMESTAMP FROM DUAL
= 31-JAN-19 06.54.35.543146 AM +00:00 		Parzialmente con formattazione data/ora diversa CURRENT_TIMESTAMP Cloud SQL per PostgreSQL restituisce un formato data/ora diverso da quello di Oracle. La formattazione della data dovrà corrispondere al formato della data e dell'ora originale:

SELECT CURRENT_TIMESTAMP FROM DUAL
= 2019-01-31 07:37:11.622187+00s
ADD_MONTHS Restituisce la data più i mesi interi:

ADD_MONTHS(SYSDATE, 1)
= 31-JAN-19 		No N/D Per ottenere la stessa funzionalità in Cloud SQL per PostgreSQL, utilizza + / - e specifica l'intervallo di tempo:

SELECT CURRENT_TIMESTAMP + INTERVAL '1 MONTH'
= 2019-01-31 07:37:11.622187+00s
EXTRACT
(parte data)		 Restituisce il valore di un campo data/ora specificato da un'espressione di data/ora o intervallo:

EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019 		Sì EXTRACT
(parte data)		 Equivalente a Oracle:

EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019
LAST_DAY Restituisce la data dell'ultimo giorno del mese contenente la data specificata:

LAST_DAY('01-JAN-2019')
= 31-JAN-19 		No N/D Come soluzione alternativa, usa DATE_TRUNC e un operatore + per calcolare l'ultimo giorno del mese. È necessaria una formattazione della data per eguagliare la formattazione della data/dell'ora originale:

SELECT DATE_TRUNC('MONTH', DATE '01-JAN-2019') + INTERVAL '1 MONTH -1 DAY'
= 2019-01-31
MONTH_BETWEEN Restituisce il numero di mesi tra le date date1 e date2:

MONTHS_BETWEEN(SYSDATE, SYSDATE-60)
= 1.96 		Parzialmente
con
funzione di formattazione di date e ore diverse		 AGE La funzione AGE di Cloud SQL per PostgreSQL restituisce l'intervallo tra due timestamp:

AGE(DATE '01-JAN-2019', DATE '01-JAN-2019' - 60)
= 1 mon 29 days
Per ottenere gli stessi valori della funzione MONTH_BETWEEN di Oracle, è necessaria una conversione più specifica.
TO_CHAR (data/ora) Converte un tipo di dati data/ora o timestamp in un valore di VARCHAR2
tipo di dati nel formato specificato dal formato della data:

TO_CHAR(SYSDATE,'DD-MM-YYYY HH24:MI:SS')
= 01-01-2019 10:01:01 		Sì To_CHAR Equivalente a Oracle:

TO_CHAR(CURRENT_TIMESTAMP,'DD-MM-YYYY HH24:MI:SS');
01-01-2019 10:01:01
Funzioni di codifica e decodifica
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL Implementazione o specifica della funzione Cloud SQL per PostgreSQL
DECODE Confronta l'espressione con ciascun valore di ricerca uno alla volta utilizzando un statement IF-THEN-ELSE. No CASE Utilizza l'istruzione CASE di Cloud SQL per PostgreSQL per ottenere una funzionalità simile.
DUMP Restituisce un valore VARCHAR2 contenente il codice del tipo di dati, la lunghezza in byte e la rappresentazione interna dell'espressione. No N/D Non supportati.
ORA_HASH Calcola un valore hash per una determinata espressione. No MD5 / SHA224 / SHA256 / SHA385 / SHA512 Utilizza la funzione Cloud SQL per PostgreSQL MD5 per la versione a 128 bit checksum o la funzione SHA per
a 160 bit checksum per generare valori hash.
Funzioni di conversione
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL Implementazione o specifica della funzione Cloud SQL per PostgreSQL
CAST Converte un tipo di dati incorporato o un valore con tipo di raccolta in un altro tipo di dati incorporato o un valore con tipo di raccolta:

CAST('1' as int) + 1
= 2 		Parzialmente CAST La funzione CAST di Cloud SQL per PostgreSQL è simile alla funzionalità CAST di Oracle, ma in alcuni casi deve essere aggiustata a causa delle differenze nei tipi di dati tra i due database:

CAST('1' as int) + 1
= 2
CONVERT Converte una stringa di caratteri da un set di caratteri a un altro:

CONVERT ( 'Ä Ê Í Õ Ø A B C D E ', 'US7ASCII', 'WE8ISO8859P1')
= ?? ?? ?? A B C 		Parzialmente CONVERT La funzione CONVERT di Cloud SQL per PostgreSQL restituisce un valore bytea, che è una stringa binaria anziché VARCHAR o TEXT. I set di caratteri supportati da PostgreSQL sono anch'essi diversi da Oracle.

CONVERT('Ä Ê Í Õ Ø A B C D E', 'UTF8', 'LATIN1')
= [Binary representation of the string in LATIN1 encoding]
TO_CHAR e
(stringa/numerica)		 La funzione converte un numero o una data in una stringa:

TO_CHAR(22.73,'$99.9')
= $22.7 		Parzialmente TO_CHAR La funzione TO_CHAR di Cloud SQL per PostgreSQL è simile a quella di Oracle. Cloud SQL per PostgreSQL supporta elenco leggermente diverso di stringhe di formattazione. Per impostazione predefinita, Cloud SQL per PostgreSQL riserva una colonna per il segno, quindi ci sarà uno spazio prima del segno positivo numeri. Questo problema può essere risolto utilizzando il prefisso FM:

TO_CHAR(22.73,'FM$99.9')
= $22.7
TO_DATE La funzione TO_DATE di Oracle converte una stringa in una data in base al formato data/ora specifico dell'origine:

TO_DATE('2019/01/01', 'yyyy-mm-dd')
= 01-JAN-2019 		Parzialmente TO_DATE La funzione TO_DATE di Cloud SQL per PostgreSQL è simile a quella di Oracle. Cloud SQL per PostgreSQL supporta un elenco di stringhe di formattazione leggermente diverso:

TO_DATE('2019/01/01', 'yyyy-mm-dd')
= 2019-01-01
TO_NUMBER Converte l'espressione in un valore di un tipo di dati NUMBER:

TO_NUMBER('01234')
= 1234 		Parzialmente TO_NUMBER La funzione TO_NUMBER di Cloud SQL per PostgreSQL richiede una stringa di formattazione come input, mentre è facoltativa in Oracle:

TO_NUMBER('01234','99999')
= 1234
Un'alternativa è utilizzare la funzione CAST per le conversioni che non richiedono stringhe di formattazione complesse:

CAST('01234' AS NUMERIC)
= 1234
Funzioni SELECT condizionali
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL o la specifica della funzione Cloud SQL per PostgreSQL implementazione
CASE L'istruzione CASE sceglie tra una sequenza di condizioni e esegue un
istruzione corrispondente con la seguente sintassi:

CASE WHEN condition THEN result [WHEN ...] [ELSE result] END 		Sì CASE Equivalente a Oracle:

CASE WHEN condition THEN result [WHEN ...] [ELSE result] END
Funzioni null
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL o la specifica della funzione Cloud SQL per PostgreSQL implementazione
COALESCE Restituisce la prima espressione non null nell'elenco di espressioni:

COALESCE(null, '1', 'a')
= a 		Sì COALESCE Equivalente a Oracle:

COALESCE(null, '1', 'a')
= 1
NULLIF Confronta expr1 e expr2. Se sono uguali, la funzione restituisce null. Se non sono uguali, la funzione restituisce expr1:

NULLIF('1', '2')
= 1 		Sì NULLIF Equivalente a Oracle:

NULLIF('1', '2')
= 1
NVL Sostituisci null (restituito come vuoto) con una stringa nei risultati di una query:

NVL(null, 'a')
= a 		No COALESCE In alternativa, utilizza la funzione COALESCE:

COALESCE(null, 'a')
= a
NVL2 Determina il valore restituito da una query a seconda che un
espressione è nullo o non nullo.		 No COALESCE In alternativa, utilizza la funzione COALESCE:

COALESCE(null, 1, 'a')
= 1
Funzioni di ambiente e identificatore
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL Implementazione o specifica della funzione Cloud SQL per PostgreSQL
SYS_GUID Genera e restituisce un identificatore univoco globale (valore RAW) creato
fino a 16 byte:

SELECT SYS_GUID() FROM DUAL
= 8EFA4A31468B4C6DE05011AC0200009E 		Parzialmente con nome e formato della funzione diversi UUID_GENERATE_V4 CloudSQL per Cloud SQL per PostgreSQL supporta l'estensione uuid-ossp che fornisce un elenco di funzioni di generazione di UUID come UUID_GENERATE_V4:

SELECT UUID_GENERATE_v4()
= eaf356a6-2847-478d-af3b-6883f5ac6af2
UID Restituisce un numero intero che identifica in modo univoco l'utente della sessione (l'utente
che hanno eseguito l'accesso):

SELECT UID FROM DUAL
= 43 		No N/D N/D
USER Restituisce il nome del nome utente della sessione corrente:

SELECT USER FROM DUAL
= UserName 		Sì USER Equivalente a Oracle:

SELECT USER;
= postgres
USERENV Restituisce informazioni sulla sessione utente corrente con configurazione parametro:

SELECT USERENV('LANGUAGE') FROM DUAL
= ENGLISH_AMERICA.AL32UTF8 		No N/D Sebbene non esista una funzione USERENV equivalente in Cloud SQL per PostgreSQL, i singoli parametri come USERENV('SID') possono essere recuperati utilizzando le funzioni di informazione di sistema come PG_BACKGROUND_PID().
ROWID Il server Oracle assegna a ogni riga di ogni tabella un valore ROWID univoco per identificarla. ROWID è l'indirizzo della riga che contiene il numero dell'oggetto dati, il blocco di dati della riga, la posizione della riga e il file di dati. Parzialmente con nome funzione diverso ctid ctid in Cloud SQL per PostgreSQL identifica la posizione fisica della versione di riga all'interno della relativa tabella, in modo simile a ROWID di Oracle.
ROWNUM Restituisce un numero che rappresenta l'ordine in cui una riga viene selezionata da Oracle da una tabella o da tabelle unite. No LIMIT or ROW_NUMBER() Anziché limitare il numero di risultati restituiti dalle query utilizzando ROWNUM, Cloud SQL per PostgreSQL supporta LIMIT e OFFSET per scopi simili.

Finestra di ROW_NUMBER() potrebbe essere una soluzione alternativa per ROWNUM per altri scenari. Tuttavia, l'ordinamento dei risultati devi considerare i delta sul rendimento prima di utilizzarlo come sostituzione.
Funzioni di aggregazione (di gruppo)
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL o la specifica della funzione Cloud SQL per PostgreSQL implementazione
AVG Restituisce il valore medio della colonna o dell'espressione. Sì AVG Equivalente a Oracle
COUNT Restituisce il numero di righe restituite da una query. Sì COUNT Equivalente a Oracle
COUNT (DISTINCT) Restituisce il numero di valori univoci nella colonna o nell'espressione. Sì COUNT
(DISTINCT) 		Equivalente a Oracle
MAX Restituisce il valore massimo della colonna o dell'espressione. Sì MAX Equivalente a Oracle
MIN Restituisce il valore minimo della colonna o dell'espressione. Sì MIN Equivalente a Oracle
SUM Restituisce la somma dei valori della colonna o dell'espressione. Sì SUM Equivalente a Oracle
LISTAGG Visualizza i dati all'interno di ogni gruppo in base a una singola riga specificata nel Clausola ORDER BY concatenando i valori della misura colonna:

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

-- Single line results
= Accounting, Administration, Benefits, Construction 		No STRING_AGG Utilizza la funzione Cloud SQL per PostgreSQL STRING_AGG per restituire risultati simili a quelli di Oracle, aspettati differenze di sintassi con casi:

SELECT STRING_AGG(DEPARTMENT_NAME, ', ' order by DEPARTMENT_NAME) FROM DEPARTMENTS;

-- Single line results
= Accounting, Administration, Benefits, Construction
Oracle 12c Fetch
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL o la specifica della funzione Cloud SQL per PostgreSQL implementazione
FETCH Recupera le righe di dati dal set di risultati di una query con più righe:

SELECT * FROM
EMPLOYEES
FETCH FIRST 10 ROWS ONLY; 		No LIMIT Utilizza Cloud SQL per PostgreSQL LIMIT per recuperare solo un insieme specifico di record:

SELECT * FROM EMPLOYEES LIMIT 10;

Filtri, operatori e sottoquery di base

Durante la conversione, i filtri di base, le funzioni degli operatori e le sottoquery sono relativamente semplici e richiedono uno sforzo minimo o nullo.

Note sulle conversioni

Esaminare e gestire i formati data perché Oracle e I formati Cloud SQL per PostgreSQL restituiscono risultati predefiniti diversi:

  • Per impostazione predefinita, la funzione SYSDATE di Oracle restituisce 01-AUG-19.
  • Per impostazione predefinita, la funzione CURRENT_DATE di PostgreSQL restituisce 2019-08-01 (nessun ora del giorno anche con la formattazione). Per recuperare la data e l'ora correnti, utilizza la funzione CURRENT_TIMESTAMP che per impostazione predefinita restituisce 2019-08-01 00:00:00.000000+00.
  • I formati di data e ora possono essere impostati utilizzando Cloud SQL per PostgreSQL TO_CHAR funzioni.
Funzione o sottoquery Oracle Equivalente di Cloud SQL per PostgreSQL Funzione o sottoquery corrispondente di Cloud SQL per PostgreSQL Specifica o implementazione della funzione Cloud SQL per PostgreSQL
EXISTS/ NOT EXISTS Sì EXISTS/ NOT EXISTS SELECT * FROM DEPARTMENTS D
WHERE EXISTS (SELECT 1
FROM EMPLOYEES E
WHERE
E.DEPARTMENT_ID =
D.DEPARTMENT_ID);
IN/NOT IN Sì 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 Sì LIKE/NOT LIKE SELECT * FROM EMPLOYEES
WHERE FIRST_NAME LIKE '_e_n%';
BETWEEN/ NOT BETWEEN Sì BETWEEN/
NOT BETWEEN 		SELECT * FROM EMPLOYEES
WHERE EXTRACT(YEAR FROM HIRE_DATE)
NOT BETWEEN 2001 and 2004;
AND/OR Sì AND/OR SELECT * FROM EMPLOYEES
WHERE DEPARTMENT_ID IN(100, 101)
AND (SALARY >= 1000 OR HIRE_DATE <= '2006-02-05');
SubQuery Sì SubQuery Cloud SQL per PostgreSQL supporta le sottoquery in SELECT per le istruzioni JOIN e per l'applicazione di filtri nel WHERE/AND clausole:

-- 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);
Operatori Sì Operatori Cloud SQL per PostgreSQL supporta tutti gli operatori di base:

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

Funzioni analitiche (o funzioni finestra e di classificazione)

Le funzioni di analisi di Oracle estendono la funzionalità delle operazioni SQL standard fornendo funzionalità per calcolare i valori aggregati su un gruppo di righe (ad es.RANK(), ROW_NUMBER(), FIRST_VALUE()). Queste funzioni vengono applicate ai record partizionati logicamente nell'ambito di una singola espressione di query. Sono comunemente utilizzati nel data warehousing, in combinazione con report e analisi di business intelligence.

Note sulle conversioni

Cloud SQL per PostgreSQL supporta molte funzioni analitiche. Sono note in Postgres come funzioni aggregate e funzioni finestra. Se la tua applicazione utilizza una funzione meno comune non supportata in Postgres, dovrai cercare un'estensione supportata o spostare la logica nel livello di applicazione.

La tabella seguente elenca le funzioni di analisi più comuni di Oracle.

Famiglia di funzioni Funzioni correlate Supportato da Cloud SQL per PostgreSQL
Dati e ranking RANK
AVERAGE_RANK
DENSE_RANK
ROW_NUMBER
PERCENT_RANK
CUME_DIST
NTILE
FIRST_VALUE
LAST_VALUE
OVER (PARTITION BY...) 		Sì (tranne AVERAGE_RANK)
Gerarchico CONNECT BY
HIER_ANCESTOR
HIER_CHILD_COUNT
HIER_DEPTH
HIER_LEVEL
HIER_ORDER
HIER_PARENT
HIER_TOP 		No
Ritardo LAG
LAG_VARIANCE LAG_VARIANCE_PERCENT LEAD
LEAD_VARIANCE LEAD_VARIANCE_PERCENT 		Sì (solo LAG e LEAD)

Espressione di tabella comune (CTE)

I CTE forniscono un modo per implementare la logica del codice sequenziale per riutilizzare il codice SQL troppo complessi o inefficienti per un uso multiplo. I CTE possono essere denominati e poi utilizzata più volte in parti diverse di un'istruzione SQL utilizzando WITH. Le CTE sono supportate sia da Oracle sia da Cloud SQL per PostgreSQL.

Esempi
Oracle e Cloud SQL per 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;

Istruzione MERGE

L'istruzione MERGE (o UPSERT) fornisce un mezzo per specificare singole istruzioni SQL che eseguono condizionatamente operazioni DML in un'operazione MERGE, diversamente da una singola operazione DML, in esecuzione separatamente. Seleziona i record dalla tabella di origine e, specificando una struttura logica, esegue automaticamente più operazioni DML sulla tabella di destinazione. Questa funzionalità ti aiuta a evitare di utilizzare più inserimenti, aggiornamenti o eliminazioni. Tieni presente che MERGE è un l'istruzione deterministica, il che significa che una volta che una riga è stata elaborata MERGE, non è possibile elaborarla nuovamente utilizzando la stessa istruzione MERGE l'Informativa.

Note sulle conversioni

Cloud SQL per PostgreSQL non supporta la funzionalità MERGE, a differenza Oracle Per simulare parzialmente la funzionalità MERGE, Cloud SQL per PostgreSQL fornisce INSERT ... ON CONFLICT DO UPDATE estratti conto:

  • INSERT… ON CONFLICT DO UPDATE: se una riga inserita causa un errore di violazione di un vincolo di esclusione o di violazione singola, viene eseguita l'azione alternativa specificata nella clausola ON CONFLICT DO UPDATE, ad esempio:
INSERT INTO tbl (a,b,c) VALUES (1,2,3)
  ON CONFLICT (a) DO UPDATE SET b = 2, c = 3;

Un'altra soluzione consiste nel convertire la funzionalità MERGE in un stored procedure per gestire le operazioni DML, utilizzando INSERT, UPDATE e Comandi DELETE con gestione di eccezioni e duplicati.

Suggerimenti per le istruzione SQL

Oracle offre un'ampia raccolta di hint per le query SQL che consentono agli utenti di influenzare il comportamento degli ottimizzatori, con l'obiettivo di produrre piani di esecuzione delle query più efficienti. Cloud SQL per PostgreSQL non offre un livello di istruzione SQL paragonabile, meccanismo di suggerimento per influenzare l'ottimizzatore.

Per influenzare i piani di query scelti dal pianificatore delle query, Cloud SQL per PostgreSQL fornisce un insieme di parametri di configurazione che possono essere applicati a livello di sessione. Gli effetti di queste configurazioni parametri variano dall'attivazione/disattivazione di un determinato metodo di accesso alla regolazione le costanti dei costi dello strumento di pianificazione. Ad esempio, la seguente istruzione disabilita la funzione uso da parte dello strumento di pianificazione delle query di tipi di piani di scansione sequenziali come le scansioni complete delle tabelle:

SET ENABLE_SEQSCAN=FALSE;

Per regolare la stima dei costi dello strumento di pianificazione del recupero di una pagina del disco casuale (il valore predefinito è 4,0), usa la seguente affermazione:

SET RANDOM_PAGE_COST=2.0;

La riduzione di questo valore fa sì che Cloud SQL per PostgreSQL preferisca le scansioni degli indici. Se lo aumenti, accade il contrario.

Note sulle conversioni

Poiché esistono differenze fondamentali tra gli ottimizzanti di Oracle e Cloud SQL per PostgreSQL e poiché Cloud SQL per PostgreSQL non supporta gli hint di query SQL in stile Oracle, ti consigliamo di rimuovere tutti gli hint di query durante la migrazione a Cloud SQL per PostgreSQL. Quindi, esegui test delle prestazioni rigorosi gli strumenti di Cloud SQL per PostgreSQL, esaminare le query utilizzando i piani di esecuzione e e regolare i parametri dell'istanza o della sessione in base al caso d'uso.

Piani di esecuzione

Lo scopo principale dei piani esecutivi è fornire un'analisi interna delle scelte effettuate dall'ottimizzatore delle query per accedere ai dati del database. L'ottimizzatore delle query genera piani di esecuzione per le istruzioni SELECT, INSERT, UPDATE e DELETE per gli utenti del database, consentendo inoltre agli amministratori di avere una visione migliore su query e operazioni DML specifiche. Sono particolarmente utili quando è necessario ottimizzare le prestazioni delle query, ad esempio per determinare il rendimento degli indici o per stabilire se sono presenti indici mancanti che devono essere creati.

I piani di esecuzione possono essere influenzati da volumi di dati, statistiche dei dati e istanze (parametri globali o di sessione).

Considerazioni sulle conversioni

I piani di esecuzione non sono oggetti di database di cui è necessaria la migrazione, ma sono uno strumento per analizzare le differenze di prestazioni tra Oracle e Cloud SQL per PostgreSQL che eseguono lo stesso statement su set di dati identici.

Cloud SQL per PostgreSQL non supporta la stessa sintassi, la stessa funzionalità o la stessa funzionalità del piano di esecuzione come Oracle.

Di seguito è riportato un esempio di piano di esecuzione:

Piano di esecuzione Oracle Piano di esecuzione Cloud SQL per 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)

Stored procedure, funzioni e trigger

PL/SQL è il linguaggio procedurale esteso di Oracle per creare, memorizzare e applicare soluzioni basate su codice all'interno del database. In generale, le stored procedure e le funzioni del database sono elementi di codice costituiti da ANSI SQL e dal linguaggio procedurale esteso SQL, ad esempio PL/SQL per Oracle e il linguaggio procedurale MySQL per MySQL. PL/pgSQL è per PostgreSQL lingua.

Lo scopo di queste procedure e funzioni memorizzate è fornire soluzioni per requisiti più adatti per l'esecuzione all'interno del database e non dall'applicazione (ad esempio prestazioni, compatibilità e sicurezza). Sebbene sia le stored procedure che le funzioni utilizzino PL/SQL, le stored procedure utilizzate principalmente per eseguire operazioni DDL/DML e le funzioni vengono usate principalmente per eseguire calcoli per restituire risultati specifici.

Da PL/SQL a PL/pgSQL

Dal punto di vista della migrazione da Oracle PL/SQL a Cloud SQL per PostgreSQL, PL/pgSQL è simile a Oracle PL/SQL in termini di struttura e sintassi. Tuttavia, esistono alcune differenze principali che richiedono una migrazione del codice. Ad esempio, i tipi di dati sono diversi tra Oracle e Cloud SQL per PostgreSQL e spesso è necessaria una traduzione per assicurarsi che il codice sottoposto a migrazione utilizzi i nomi dei tipi di dati corrispondenti supportati da Cloud SQL per PostgreSQL. Per una discussione dettagliata delle differenze tra i due linguaggi, consulta Porting da Oracle PL/SQL.

Privilegi e sicurezza degli oggetti di codice

In Oracle, per creare una procedura o una funzione memorizzata, l'utente deve disporre del privilegio di sistema CREATE PROCEDURE (per creare procedure o funzioni con altri utenti diversi, gli utenti del database devono disporre del privilegio CREATE ANY PROCEDURE). Per eseguire una stored procedure o una funzione, gli utenti del database devono disporre del privilegio EXECUTE.

In PostgreSQL, per creare una procedura o una funzione di codice, l'utente deve avere il privilegio USAGE. Per eseguire una procedura o una funzione, l'utente deve dispongono del privilegio EXECUTE per la procedura o la funzione.

Per impostazione predefinita, una procedura o una funzione PL/pgSQL è definita come SECURITY INVOKER, il che significa che deve essere eseguita con i privilegi dell'utente che la chiama. In alternativa, è possibile specificare SECURITY DEFINER in modo che la funzione venga eseguita con i privilegi dell'utente che ne è proprietario.

Sintassi delle funzioni e delle stored procedure di Cloud SQL per PostgreSQL

L'esempio seguente mostra la sintassi della procedura memorizzata e della funzione di Cloud SQL per 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

Un trigger è una procedura memorizzata che viene attivata quando si verifica un evento specifico. In Oracle, l'evento di attivazione è associato a una tabella, una vista, schematica o del database. I tipi di eventi di attivazione includono:

  • Istruzioni DML (Data Manipulation Language) (ad esempio INSERT, UPDATE, DELETE)
  • Istruzioni DDL (Data Definition Language) (ad esempio, CREATE, ALTER, DROP)
  • Eventi di database (ad esempio LOGON, STARTUP, SHUTDOWN)

Gli attivatori Oracle possono essere dei seguenti tipi:

  • Trigger semplice: viene attivato esattamente una volta, prima o dopo il evento di trigger specificato
  • Trigger composto: attivato in occasione di più eventi
  • Trigger INSTEAD OF: un tipo speciale di trigger DML per fornire un meccanismo di aggiornamento trasparente per viste complesse e non modificabili
  • Attivazione sistema: viene attivata in caso di eventi specifici del database

In Cloud SQL per PostgreSQL, un trigger viene attivato prima o dopo un DML su una tabella, una vista o tabella. Il trigger INSTEAD OF è supportato per fornire un meccanismo di aggiornamento per visualizzazioni. Un trigger sulle operazioni DDL è chiamato attivatore di evento. Cloud SQL per PostgreSQL non supporta gli attivatori di sistema di Oracle basati su eventi del database.

A differenza dei trigger Oracle, i trigger di Cloud SQL per PostgreSQL non supportano l'utilizzo di un blocco PL/pgSQL anonimo come corpo del trigger. Una funzione con nome che accetta zero o più argomenti e restituisce un trigger di tipo deve essere specificato la dichiarazione trigger. Questa funzione viene eseguita quando viene attivato l'attivatore.

Sintassi dei trigger di Cloud SQL per PostgreSQL e dei trigger di eventi

L'esempio seguente mostra Cloud SQL per PostgreSQL attivatore e attivatore di evento sintassi:

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 può essere uno dei seguenti valori: 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 può essere uno dei seguenti: ddl_command_start, ddl_command_end, table_rewrite e sql_drop

filter_value può essere solo: TAG

filter_value può essere una delle opzioni supportate tag di comando.

Passaggi successivi