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 ed esecuzione delle migrazioni dei database Oracle® 11g/12c a Cloud SQL per PostgreSQL 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 i relativi equivalenti Cloud SQL per PostgreSQL.

Sintassi di base di SELECT e FROM

Nome della funzionalità o della sintassi Oracle Panoramica o implementazione di Oracle Assistenza Cloud SQL per PostgreSQL Soluzione corrispondente o alternativa per 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
Sensibilità alle maiuscole dei 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 ulteriori dettagli sulla sintassi SELECT di Cloud SQL per PostgreSQL, consulta la 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 contribuire a semplificare le query complesse rimuovendo calcoli composti o eliminando le operazioni di join, nonché comprimendo diverse query distinte in un'unica query semplificata.
  • Nota sulla conversione: le visualizzazioni in linea di Oracle non richiedono l'utilizzo di alias, mentre Cloud SQL per PostgreSQL richiede alias specifici per 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 JOIN di Oracle sono supportate dalle istruzioni JOIN di Cloud SQL per PostgreSQL. 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, INTERSECT e MINUS

Cloud SQL per PostgreSQL supporta gli operatori Oracle UNION, UNION ALL e 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: collega i set di risultati di due o più istruzioni SELECT ed elimina i record duplicati.
  • UNION ALL: unisce i set 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 l'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): confronta due o più comandi SELECT, restituendo solo le righe distinte della prima query che non vengono restituite dagli altri comandi.
  • 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 di Oracle Assistenza Cloud SQL per PostgreSQL Soluzione corrispondente o alternativa 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ì (Convert MINUS a EXCEPT in PostgreSQL) SELECT COL1 FROM TBL1
EXCEPT
SELECT COL1 FROM TBL2

Funzioni scalari (una riga) e di gruppo

Cloud SQL per PostgreSQL fornisce un ampio elenco di funzioni scalari (una riga) e di aggregazione. Alcune funzioni di Cloud SQL per PostgreSQL sono simili alle loro controparti Oracle (per nome e funzionalità o con un nome diverso, ma con funzionalità simili). Sebbene le funzioni di Cloud SQL per PostgreSQL possano avere nomi identici alle relative controparti di Oracle, 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 di Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL Implementazione o specifica della funzione Cloud SQL per PostgreSQL
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 in minuscolo o in maiuscolo:

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

LOWER('SQL') = sql
LPAD/RPAD Restituisce expr1, con spazi iniziali o finali per una lunghezza di n caratteri 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 Equivalente 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 una funzione instr integrata. 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 della stringa di sostituzione è facoltativo in Oracle, mentre è obbligatorio 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 specificando una stringa vuota come stringa di sostituzione.

REPLACE('ORADB', 'ORA', 'PostgreSQL')
= PostgreSQLDB
TRIM Taglia i caratteri iniziali o finali (o entrambi) di 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 del primo carattere di char:

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

ASCII('A') = 65
CHR Restituisce il valore del codice ASCII, ovvero un valore numerico compreso tra 0 e 225, a 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 espressione regolare 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 funzionalità simili.
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 un pattern
di espressione regolare in una posizione (indice) di una stringa.		 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 di 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 della divisione di m per n:

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

MOD(10, 3) = 1
ROUND Restituisce n arrotondato a cifre intere 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 di Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL Implementazione o specifica della funzione Cloud SQL per PostgreSQL
SYSDATE Restituisce la data e l'ora correnti impostate per il sistema operativo su cui risiede il 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 data/ora diverso da quello di 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 è obbligatoria per fare in modo che corrisponda al formato della data/ora originale:

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. La formattazione della data è obbligatoria per fare in modo che corrisponda al formato data/ora originale:

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 gli operatori + / - 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, utilizza 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 diversa della data e dell'ora		 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 di 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 MD5 di Cloud SQL per PostgreSQL per il controllo di congruenza
di 128 bit o la funzione SHA per il controllo di congruenza
di 160 bit per generare valori hash.
Funzioni di conversione
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente di 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 modificata 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 insieme 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. Anche i set di caratteri supportati da PostgreSQL sono diversi da quelli di Oracle.

CONVERT('Ä Ê Í Õ Ø A B C D E', 'UTF8', 'LATIN1')
= [Binary representation of the string in LATIN1 encoding]
TO_CHAR
(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 un elenco leggermente diverso di stringhe di formattazione. Per impostazione predefinita, Cloud SQL per PostgreSQL preleva una colonna per il segno, quindi verrà inserito uno spazio prima dei numeri positivi. 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 di Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL Implementazione o specifica della funzione Cloud SQL per PostgreSQL
CASE L'istruzione CASE sceglie da una sequenza di condizioni ed 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 di Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL Implementazione o specifica della funzione Cloud SQL per PostgreSQL
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 in base al fatto che un'espressione
specificata sia null o non null.		 No COALESCE In alternativa, utilizza la funzione COALESCE:

COALESCE(null, 1, 'a')
= 1
Funzioni di ambiente e identificatori
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente di 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) costituito da 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 ha eseguito l'accesso):

SELECT UID FROM DUAL
= 43 		No N/D N/D
USER Restituisce il nome dell'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 la configurazione del parametro corrente:

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 della 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 che utilizzano ROWNUM, Cloud SQL per PostgreSQL supporta LIMIT e OFFSET per scopi simili.

ROW_NUMBER() funzione window potrebbe essere una soluzione alternativa per sostituire ROWNUM di Oracle per altri scenari. Tuttavia, prima di utilizzarlo come sostituzione, devi prendere in considerazione l'ordinamento dei risultati e i delta di rendimento.
Funzioni di aggregazione (di gruppo)
Funzione Oracle Specifiche o implementazione di funzioni Oracle Equivalente di Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL Implementazione o specifica della funzione Cloud SQL per PostgreSQL
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 Mostra i dati all'interno di ciascun gruppo in base a una singola riga specificata nella clausola ORDER BY concatenando i valori della colonna della misura:

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 STRING_AGG di Cloud SQL per PostgreSQL per ritornare risultati simili a quelli di Oracle. Prevedi differenze di sintassi in alcuni 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 di Cloud SQL per PostgreSQL Funzione corrispondente di Cloud SQL per PostgreSQL Implementazione o specifica della funzione Cloud SQL per PostgreSQL
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 la clausola LIMIT di Cloud SQL per PostgreSQL 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

Esamina e risolvi i problemi relativi ai formati delle date perché i formati Oracle e 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 01-08-2019 00:00:00.000000+00.
  • I formati di data e ora possono essere impostati utilizzando le funzioni Cloud SQL per PostgreSQL TO_CHAR.
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 a livello di SELECT per gli statement JOIN e per i filtri nelle clausole WHERE/AND:

-- 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 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 un'unica 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 di analisi. In Postgres sono note 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ì (eccetto 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)

Le CTE forniscono un modo per implementare la logica del codice sequenziale al fine di riutilizzare il codice SQL che potrebbe essere troppo complesso o non efficiente per un uso multiplo. Le CTE possono essere nominate e poi utilizzate più volte in parti diverse di un'istruzione SQL utilizzando la clausola 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 statement deterministico, il che significa che una volta elaborata una riga dall'istruzione MERGE, non può essere elaborata di nuovo utilizzando la stessa istruzione MERGE.

Note sulle conversioni

A differenza di Oracle, Cloud SQL per PostgreSQL non supporta la funzionalità MERGE. Per simulare parzialmente la funzionalità MERGE, Cloud SQL per PostgreSQL fornisce le istruzioni INSERT ... ON CONFLICT DO UPDATE:

  • 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 una procedura memorizzata per gestire le operazioni DML, utilizzando i comandi INSERT, UPDATE e DELETE con gestione di eccezioni e duplicazioni.

Suggerimenti per le istruzione SQL

Oracle fornisce una vasta raccolta di suggerimenti per query SQL che consente agli utenti di influenzare il comportamento dell'ottimizzatore, al fine di produrre piani di esecuzione delle query più efficienti. Cloud SQL per PostgreSQL non offre un meccanismo di suggerimenti paragonabile a livello di istruzione SQL 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 questi parametri di configurazione vanno dall'abilitazione/disattivazione di un determinato metodo di accesso all'aggiustamento delle costanti di costo del pianificatore. Ad esempio, l'istruzione seguente disattiva l'uso da parte del pianificatore delle query di tipi di piani di scansione sequenziale come le scansioni complete della tabella:

SET ENABLE_SEQSCAN=FALSE;

Per modificare la stima dei costi del pianificatore di un recupero di pagine del disco casuale (il valore predefinito è 4,0), utilizza la seguente istruzione:

SET RANDOM_PAGE_COST=2.0;

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

Note sulle conversioni

Poiché esistono differenze fondamentali tra gli ottimizzatori 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. Poi, esegui test rigorosi delle prestazioni tramite gli strumenti Cloud SQL per PostgreSQL, esamina le query utilizzando i piani di esecuzione e modifica i parametri dell'istanza o della sessione in base al caso d'uso.

Piani di esecuzione

Lo scopo principale dei piani di esecuzione è fornire un'analisi approfondita delle scelte fatte 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 dai volumi di dati, dalle statistiche dei dati e dai parametri di istanza (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, funzionalità o output del piano di esecuzione di 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 la creazione, la memorizzazione e l'applicazione di 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 SQL esteso, ad esempio PL/SQL per Oracle e il linguaggio procedurale MySQL per MySQL. PL/pgSQL è il linguaggio procedurale esteso di PostgreSQL.

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 procedure memorizzate sia le funzioni utilizzino PL/SQL, le procedure memorizzate vengono principalmente utilizzate per eseguire operazioni DDL/DML e le funzioni vengono principalmente utilizzate per eseguire calcoli al fine di restituire risultati specifici.

PL/SQL a PL/pgSQL

Dal punto di vista della migrazione da PL/SQL di Oracle a Cloud SQL per PostgreSQL, PL/pgSQL è simile a PL/SQL di Oracle in termini di struttura e sintassi. Tuttavia, ci sono 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 disporre 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 la possiede.

Sintassi delle procedure e delle funzioni memorizzate 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, uno schema o al database. I tipi di eventi di attivazione includono:

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

Gli attivatori Oracle possono essere dei seguenti tipi:

  • Attivatore semplice: viene attivato esattamente una volta prima o dopo l'evento di attivazione specificato
  • Trigger composto: attivato in più eventi
  • Attivatore INSTEAD OF: un tipo speciale di attivatore DML per fornire un meccanismo di aggiornamento trasparente per visualizzazioni 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'operazione DML su una tabella, una vista o una tabella esterna specifica. L'attivatore INSTEAD OF è supportato per fornire un meccanismo di aggiornamento alle visualizzazioni. Un trigger per le operazioni DDL è chiamato trigger evento. Cloud SQL per PostgreSQL non supporta gli attivatori di sistema di Oracle basati su eventi del database.

A differenza degli attivatori Oracle, gli attivatori Cloud SQL per PostgreSQL non supportano l'utilizzo di un blocco PL/pgSQL anonimo come corpo dell'attivatore. Nella dichiarazione dell'attivatore deve essere fornita una funzione con nome che accetta zero o più argomenti e restituisce un attivatore di tipo. Questa funzione viene eseguita quando viene attivato l'attivatore.

Sintassi degli attivatori e degli attivatori di eventi di Cloud SQL per PostgreSQL

L'esempio seguente mostra la sintassi dell'attivatore e dell'attivatore evento di Cloud SQL per 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 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 valori: ddl_command_start, ddl_command_end, table_rewrite, sql_drop

filter_value può essere solo: TAG

filter_value può essere uno dei tag comando supportati.

Passaggi successivi