Questo documento illustra le differenze di base delle query tra Oracle® e Cloud SQL per MySQL e il modo in cui le funzionalità di Oracle vengono mappate a quelle di Cloud SQL per MySQL. Descrive inoltre considerazioni sulle prestazioni di Cloud SQL per MySQL e modi per analizzare e ottimizzare le prestazioni delle query su Google Cloud. Anche se questo documento tratta le tecniche per ottimizzare le procedure e i trigger archiviati per Cloud SQL per MySQL, non spiega come tradurre il codice PL/SQL in stored procedure e funzioni MySQL.
Quando si convertono query da Oracle Database a Cloud SQL per MySQL, ci sono alcune differenze di dialetto SQL da considerare. Esistono anche diverse funzioni integrate diverse o incompatibili tra le due piattaforme di database.
Differenze di base nelle query
Sebbene Oracle e Cloud SQL per MySQL supportino ANSI SQL, esistono diverse differenze fondamentali durante l'esecuzione di query sui dati, principalmente relative all'uso delle funzioni di sistema.
La tabella seguente evidenzia le differenze della sintassi SELECT e FROM per Oracle e Cloud SQL per MySQL.
| Nome funzionalità Oracle | Implementazione di Oracle | Supporto di Cloud SQL per MySQL | Equivalente Cloud SQL per MySQL |
|---|---|---|---|
| Sintassi di base SQL per il recupero dei dati |
SELECTFROMWHEREGROUP BYHAVINGORDER BY
|
Sì |
SELECTFROMWHEREGROUP BYHAVINGORDER BY
|
SELECT
per stampa di output |
SELECT 1 FROM DUAL
|
Sì |
SELECT 1oppure SELECT 1 FROM DUAL
|
| Alias colonna | SELECT COL1 AS C1
|
Sì |
SELECT COL1 AS C1oppure SELECT COL1 C1 |
| Sensibilità alle maiuscole dei nomi della tabella | Nessuna sensibilità alle maiuscole
(ad esempio, il nome della tabella può essere orders e
ORDERS) |
No | Distinzione tra maiuscole e minuscole in base al nome della tabella definito (ad esempio, il nome della tabella
può essere solo orders o ORDERS) |
Visualizzazioni in linea
Le viste incorporate
(note anche come tabelle derivate) sono istruzioni SELECT, situate nella clausola FROM
e utilizzate come sottoquery. Le viste in linea possono aiutare a rendere più semplici le query complesse, rimuovendo i calcoli composti o eliminando le operazioni di join, accorpando al contempo più query separate in un'unica query semplificata.
L'esempio seguente illustra un esempio di conversione da Oracle 11g/12c a Cloud SQL per MySQL per una vista in linea.
Una visualizzazione in linea in Oracle 11g/12c:
SELECT FIRST_NAME,
DEPARTMENT_ID,
SALARY,
DATE_COL
FROM EMPLOYEES,
(SELECT SYSDATE AS DATE_COL FROM DUAL);
Una visualizzazione di lavoro in Cloud SQL per MySQL 5.7 con un alias:
SELECT FIRST_NAME,
DEPARTMENT_ID,
SALARY,
DATE_COL
FROM EMPLOYEES, (SELECT SYSDATE() AS DATE_COL FROM DUAL) AS A1;
Unioni
I tipi di join di Oracle sono supportati da Cloud SQL per MySQL, ad eccezione di FULL JOIN.
I join di Cloud SQL per MySQL supportano l'uso di sintassi alternativa, come la clausola USING, la clausola WHERE al posto della clausola ON e SUBQUERY nell'istruzione JOIN.
La tabella seguente mostra un esempio di conversione JOIN.
Tipo Oracle JOIN |
Supporto di Cloud SQL per MySQL | Sintassi JOIN di Cloud SQL per MySQL
|
|---|---|---|
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 |
No | Valuta l'utilizzo di UNION con LEFT e
RIGHT JOINS:
SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E LEFT JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID
UNION
SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E RIGHT JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
|
LEFT JOIN
[ OUTER ]
|
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;
|
Sebbene Cloud SQL per MySQL supporti le funzioni UNION e UNION ALL, non supporta le funzioni INTERSECT e MINUS di Oracle:
UNIONallega l'insieme di risultati di due istruzioniSELECTdopo l'eliminazione dei record duplicati.UNION ALLallega l'insieme di risultati di due istruzioniSELECTsenza eliminare i record duplicati.INTERSECTrestituisce l'intersezione di due istruzioniSELECT, solo se esiste un record nei set di risultati di entrambe le query.MINUSconfronta due o più istruzioniSELECT, restituendo solo righe distinte dalla prima query che non sono state restituite dalla seconda.
La tabella seguente mostra alcuni esempi di conversione da Oracle a Cloud SQL per MySQL.
| Funzione Oracle | Implementazione di Oracle | Supporto di Cloud SQL per MySQL | Equivalente Cloud SQL per MySQL |
|---|---|---|---|
UNION |
SELECT COL1 FROM TBL1UNIONSELECT COL1 FROM TBL2
|
Sì | SELECT COL1 FROM TBL1UNIONSELECT COL1 FROM TBL2
|
UNION ALL |
SELECT COL1 FROM TBL1UNION ALLSELECT COL1 FROM TBL2
|
Sì | SELECT COL1 FROM TBL1UNION ALLSELECT COL1 FROM TBL2
|
INTERSECT |
SELECT COL1 FROM TBL1INTERSECTSELECT COL1 FROM TBL2
|
No |
SELECT COL1 FROM TBL1WHERE COL1 IN(SELECT COL1 FROM TBL2)
|
MINUS |
SELECT COL1 FROM TBL1MINUSSELECT COL1 FROM TBL2
|
No | SELECT A.COL1
FROM TBL1 A LEFT JOIN TBL2 B
ON USING(COL1)
WHERE B.COL1 IS NULL
|
Funzioni scalari e di gruppo
Cloud SQL per MySQL fornisce un elenco completo di funzioni scalari (a riga singola) e di aggregazione. Alcune funzioni di Cloud SQL per MySQL sono simili alle rispettive controparti Oracle (per nome e funzionalità o con un nome diverso ma con funzionalità simile). Sebbene alcune funzioni di Cloud SQL per MySQL possano avere nomi identici alle loro controparti Oracle, possono anche presentare funzionalità diverse.
La tabella seguente descrive dove le funzioni dei caratteri Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità, mentre è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
CONCAT |
Restituisce la prima stringa concatenata con la seconda stringa: CONCAT('A', 1) = A1
|
Sì | CONCAT |
CONCAT('A', 1) = A1 |
CONCAT USING PIPE |
FNAME |' '| LNAME |
No | CONCAT |
CONCAT(FNAME, ' ', LNAME) |
LOWER o UPPER |
Restituisce la stringa con tutte le lettere minuscole o maiuscole:LOWER('SQL') = sql
|
Sì | LOWER o UPPER |
LOWER('SQL') = sql |
LPAD/RPAD |
Restituisce expression1, a sinistra o a destra con spaziatura interna a
n caratteri con la sequenza di caratteri in
expression2:LPAD('A',3,'*') = **A
|
Sì | LPAD o RPAD |
LPAD('A',3,'*') = **A |
SUBSTR |
Restituisce una parte della stringa, a partire dalla posizione x (in questo caso 3), con una lunghezza pari a y. La prima posizione nella stringa è 1.
SUBSTR('MySQL', 3, 3)
= SQL
|
Sì | SUBSTR |
SUBSTR('MySQL', 3, 3)
= SQL
|
INSTR |
Restituisce la posizione (indice) di una stringa da una determinata stringa:
INSTR('MySQL', 'y')
= 2
|
Sì | INSTR |
INSTR('MySQL', 'y')
= 2
|
REPLACE |
Restituisce una stringa con ogni occorrenza di una stringa di ricerca sostituita da una
stringa di sostituzione:
REPLACE('ORADB', 'ORA', 'MySQL')
= MySQLDB
|
Sì | REPLACE |
REPLACE('ORADB', 'ORA', 'MySQL')
= MySQLDB
|
TRIM |
Elimina i caratteri iniziali e finali (o entrambi) da una stringa:
TRIM(both '-' FROM '-MySQL-')
= MySQL
TRIM(' MySQL ')
= MySQL
|
Sì | TRIM |
TRIM(both '-' FROM '-MySQL-')
= MySQL
TRIM(' MySQL ')
= MySQL
|
LTRIM/RTRIM |
Rimuove dal lato sinistro o destro di una stringa tutti i caratteri visualizzati nella ricerca:
LTRIM(' MySQL', ' ')
= MySQL
|
Parzialmente | LTRIM or RTRIM |
Le funzioni Oracle LTRIM e RTRIM utilizzano un secondo parametro che specifica quali caratteri iniziali o finali rimuovere dalla stringa. Le funzioni di Cloud SQL per MySQL rimuovono solo gli spazi vuoti iniziali e finali dalla stringa specificata:
LTRIM(' MySQL')
= MySQL
|
ASCII |
Recupera un singolo carattere e restituisce il relativo codice ASCII numerico: ASCII('A') = 65
|
Sì | ASCII |
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
|
Richiede un nome funzione diverso | CHAR |
Cloud SQL per MySQL utilizza la funzione CHAR per la stessa
funzionalità, quindi devi modificarne il nome:CHAR(65) = A
|
LENGTH |
Restituisce la lunghezza di una determinata stringa:LENGTH('MySQL') = 5
|
Sì | LENGTH |
LENGTH('MySQL') = 5 |
REGEXP_REPLACE |
Cerca in una stringa un pattern di espressione regolare: REGEXP_REPLACE('John', '[hn].', 'e') = Joe
|
No | N/A | Funzionalità supportata a partire da MySQL versione 8. Come soluzione alternativa, utilizza la
funzione REPLACE, se possibile, oppure sposta la logica al
livello di applicazione. |
REGEXP_SUBSTR |
Estende la funzionalità della funzione SUBSTR 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/A | Funzionalità supportata a partire da MySQL versione 8. Come soluzione alternativa, utilizza la funzione SUBSTR, se possibile, oppure sposta la logica al livello di applicazione |
REGEXP_COUNT |
Restituisce il numero di volte in cui un pattern si verifica in una stringa di origine | No | N/A | Nessuna funzione equivalente disponibile per Cloud SQL per MySQL. Sposta questa logica al livello dell'applicazione. |
REGEXP_INSTR |
Cerca una posizione di stringa (indice) per un modello di espressione regolare | No | N/A | Funzionalità supportata a partire da MySQL versione 8. Se utilizzi una versione precedente, sposta questa logica al livello dell'applicazione. |
REVERSE |
Restituisce la stringa inversa per una determinata stringa:
REVERSE('MySQL')
= LQSyM
|
Sì | REVERSE |
REVERSE('MySQL')
= LQSyM
|
La tabella seguente descrive dove le funzioni numeriche di Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità e dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
ABS |
Restituisce il valore assoluto di un numero specifico: ABS(-4.6) = 4.6 |
Sì | ABS |
ABS(-4.6) = 4.6 |
CEIL |
Restituisce il numero intero più piccolo maggiore o uguale al numero specificato: CEIL(21.4) = 22 |
Sì | CEIL |
CEIL(21.4) = 22 |
FLOOR |
Restituisce il numero intero più grande uguale o inferiore al numero specificato: FLOOR(-23.7) = -24
|
Sì | FLOOR |
FLOOR(-23.7) = -24 |
MOD |
Restituisce il resto di m diviso per
n:MOD(10, 3) = 1
|
Sì | MOD |
MOD(10, 3) = 1 |
ROUND |
Restituisce n arrotondato al numero intero a destra del separatore decimale:ROUND(1.39, 1) = 1.4 |
Sì | ROUND |
ROUND(1.39, 1) = 1.4 |
TRUNC(numero) |
Restituisce n1 troncato a n2 posizioni decimali. Il secondo parametro è facoltativo.
TRUNC(99.999) = 99
TRUNC(99.999, 0) = 99
|
Richiede un nome funzione diverso | TRUNCATE(numero) |
La funzione Cloud SQL per MySQL ha un nome diverso e il secondo parametro è obbligatorio. TRUNCATE(99.999, 0) = 99
|
La tabella seguente descrive dove le funzioni Oracle e Cloud SQL per MySQL
datetime sono equivalenti per nome e funzionalità, ma dove è consigliata una
conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
SYSDATE |
Restituisce la data e l'ora correnti impostate per il sistema operativo su cui si trova il server di database:
SELECT SYSDATE
FROM DUAL;
= 31-JUL-2019
|
Sì | SYSDATE() |
Cloud SQL per MySQL
SELECT SYSDATE()
FROM DUAL;
= 2019-01-31 10:01:01.0
Puoi modificare il formato |
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
|
Richiede un nome funzione diverso |
CURRENT_
TIMESTAMP
|
La funzione Cloud SQL per MySQL restituisce un formato datetime diverso per impostazione predefinita. Per riformattare l'output, utilizza la funzione DATE_FORMAT().
SELECT CURRENT_TIMESTAMP
FROM DUAL;
= 2019-01-31 06:55:07
|
LOCAL_
TIMESTAMP
|
Restituisce la data e l'ora correnti come tipo di TIMESTAMP:
SELECT LOCALTIMESTAMP
FROM DUAL
= 01-JAN-19 10.01.10.123456 PM
|
Restituisce un formato datetime diverso |
LOCAL_
TIMESTAMP
|
La funzione Cloud SQL per MySQL restituisce un formato datetime diverso rispetto al formato predefinito per Oracle. Per riformattare l'output, utilizza la funzione DATE_FORMAT().
SELECT LOCAL_TIMESTAMP
FROM DUAL
= 2019-01-01 10:01:01.0
|
CURRENT_DATE |
Restituisce la data corrente:
SELECT CURRENT_DATE
FROM DUAL
= 31-JAN-19
|
Restituisce un formato datetime diverso |
CURRENT_
DATE
|
La funzione Cloud SQL per MySQL restituisce un formato datetime diverso. Per riformattare l'output, utilizza la funzione DATE_FORMAT().
SELECT CURRENT_DATE
FROM DUAL
= 2019-01-31
|
CURRENT_
TIMESTAMP
|
Restituisce la data e l'ora correnti:
SELECT CURRENT_TIMESTAMP
FROM DUAL
= 31-JAN-19 06.54.35.543146 AM +00:00
|
Restituisce un formato datetime diverso |
CURRENT_
TIMESTAMP
|
La funzione Cloud SQL per MySQL restituisce un formato datetime diverso. Per riformattare l'output, utilizza la funzione DATE_FORMAT().
SELECT CURRENT_TIMESTAMP
FROM DUAL
= 2019-01-31 06:55:07
|
ADD_MONTHS |
Restituisce la data più mesi interi:
ADD_MONTHS(SYSDATE, 1)
= 31-JAN-19
|
Richiede un nome funzione diverso | ADDDATE |
La funzione Cloud SQL per MySQL restituisce un formato datetime diverso. Per riformattare l'output, utilizza la funzione DATE_FORMAT().
ADDDATE(SYSDATE(), 1)
= 2019-08-01 06:42:49.0
|
EXTRACT (parte della data) |
Restituisce il valore di un campo datetime in base a un'espressione di intervallo:
EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019
|
Sì | EXTRACT (parte della data) |
EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019
|
LAST_DAY |
Restituisce l'ultimo giorno del mese per una data specificata:
LAST_DAY('01-JAN-2019')
= 31-JAN-19
|
Parzialmente | LAST_DAY |
La funzione Cloud SQL per MySQL restituisce un formato datetime diverso rispetto al formato predefinito per Oracle. Per riformattare l'output, utilizza la funzione DATE_FORMAT().
LAST_DAY('2019-01-01')
= 2019-01-31
|
MONTH_
BETWEEN
|
Restituisce il numero di mesi compresi tra le date specificate
date1 e date2:
MONTHS_BETWEEN(
SYSDATE, SYSDATE-60)
= 1.96
|
Parzialmente |
PERIOD_DIFF
|
La funzione PERIOD_DIFF di Cloud SQL per MySQL restituisce la differenza in mesi come numero intero tra due periodi (formattato come YYMM o YYYYMM):
PERIOD_DIFF(
'201903', '201901')
= 2
|
TO_CHAR (Datetime) |
Converte un numero, datetime o un tipo di timestamp in un
tipo di stringa
TO_CHAR(
SYSDATE,'DD-MM-YYYY HH24:MI:SS')
= 01-01-2019 10:01:01
|
Richiede un nome funzione diverso | DATE_FORMAT |
La funzione DATE_FORMAT di Cloud SQL per MySQL formatta un valore
di data in base a una stringa di formato:
DATE_FORMAT(
SYSDATE(),'%d-%m-%Y %H:%i:%s')
01-01-2019 10:01:01
|
La tabella seguente descrive dove le funzioni di codifica e decodifica di Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità e dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
DECODE |
Confronta l'espressione con ogni valore di ricerca uno alla volta utilizzando la funzionalità di un'istruzione IF-THEN-ELSE |
No | CASE |
Utilizza l'istruzione CASE di Cloud SQL per MySQL per funzionalità simili |
DUMP |
Restituisce un valore VARCHAR2 contenente il codice del tipo di dati, la lunghezza in byte e la rappresentazione interna dell'espressione |
No | N/A | Non supportata |
ORA_HASH |
Calcola un valore hash per una data espressione | No | MD5 or SHA |
Utilizza la funzione MD5 per i checksum a 128 bit o la funzione SHA per i checksum a 160 bit |
La tabella seguente descrive dove le funzioni di conversione di Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità, mentre è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
CAST |
Converte un tipo di dati integrato o un valore di raccolta in un altro
tipo di dati integrato o valore di raccolta:
CAST('1' as int) + 1
= 2
|
Parzialmente | CAST |
Modifica a seconda che sia richiesta una conversione esplicita o implicita:
CAST('1' AS SIGNED) + 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 MySQL richiede alcune
modifiche alla sintassi e ai parametri:
CONVERT(
'Ä Ê Í A B C ' USING utf8)
= Ä Ê Í A B C
|
TO_CHAR (stringa/numerica) |
La funzione converte un numero o una data in una stringa:
TO_CHAR(22.73,'$99.9')
= $22.7
|
No | FORMAT |
La funzione FORMAT di Cloud SQL per MySQL converte un numero in
un formato come #,###,###.##, arrotondandolo a una posizione decimale e poi restituendo il risultato come stringa:
CONCAT('$',
FORMAT(22.73, 1))
= $22.7
|
TO_DATE |
La funzione TO_DATE di Oracle converte una stringa in una data in base a un formato datetimecode:
TO_DATE(
'2019/01/01', 'yyyy-mm-dd')
= 01-JAN-2019
|
Richiede un nome funzione diverso | STR_TO_DATE |
La funzione STR_TO_DATE di Cloud SQL per MySQL utilizza una stringa e restituisce una data in base al formato datetime:
STR_TO_DATE(
'2019/01/01', '%Y/%m/%d')
= 2019-01-01
|
TO_NUMBER |
Converte l'espressione in un valore di un tipo di dati NUMBER:
TO_NUMBER('01234')
= 1234
|
Richiede un nome funzione diverso | CAST |
Utilizza la funzione CAST di Cloud SQL per MySQL per restituire lo stesso
risultato della funzione TO_NUMBER Oracle:
CAST('01234' as SIGNED)
= 1234
|
La tabella seguente descrive dove le funzioni SELECT condizionali di Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità e dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
CASE |
L'istruzione CASE sceglie in una sequenza di condizioni ed
esegue un'istruzione corrispondente con la seguente sintassi:
CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END
|
Sì | CASE |
Oltre alla funzione CASE, Cloud SQL per MySQL
supporta l'uso della gestione condizionale IF/ELSE
all'interno dell'istruzione SELECT:
CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END
|
La tabella seguente descrive dove le funzioni null di Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità e dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
COALESCE |
Restituisce la prima espressione con valore non null nell'elenco di espressioni:
COALESCE(
null, '1', 'a')
= a
|
Sì | COALESCE |
COALESCE(
null, '1', 'a')
= 1
|
NULLIF |
Esegue un confronto tra expression1 e expression2. Se sono uguali, la funzione restituisce null.
Se non sono uguali, la funzione restituisce
expression1:
NULLIF('1', '2')
= a
|
Sì | NULLIF |
NULLIF('1', '2')
= a
|
NVL |
Sostituisce un valore null con una stringa nei risultati di una query:
NVL(null, 'a')
= a
|
No | IFNULL |
IFNULL(null, 'a')
= a
|
NVL2 |
Determina il valore restituito da una query a seconda che un'espressione sia nulla o meno | No | CASE |
L'istruzione CASE sceglie in base a una sequenza di condizioni ed esegue un'istruzione corrispondente:
CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END
|
La tabella seguente descrive dove le funzioni di identificatore e ambiente Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità e dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
SYS_GUID |
Genera e restituisce un identificatore univoco a livello globale (valore RAW)
costituito da 16 byte:
SELECT SYS_GUID()
FROM DUAL
=
8EFA4A31468B4C6DE05011AC0200009E
|
No | REPLACE e UUID |
Come soluzione alternativa, utilizza le funzioni REPLACE e UUID per simulare la funzione SYS_GUID:
REPLACE(
UUID(), '-', '')
|
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/A | N/A |
USER |
Restituisce il nome utente dell'utente collegato alla sessione corrente:
SELECT USER FROM DUAL
= username
|
Sì | USER + INSTR + SUBSTR |
La funzione USER di Cloud SQL per MySQL restituisce il
nome utente e il nome host (root@IP_ADDRESS) per la
connessione. Per recuperare solo il nome utente, utilizza le funzioni di supporto aggiuntive:
SELECT
SUBSTR(USER(), 1, INSTR(USER(), '@') -1) FROM DUAL
= root
|
USERENV |
Restituisce informazioni sulla sessione Oracle corrente, ad esempio la lingua della sessione:
SELECT USERENV('LANGUAGE')
FROM DUAL
= ENGLISH_AMERICA.
AL32UTF8
|
No |
SHOW SESSION
VARIABLES
|
L'istruzione SHOW SESSION VARIABLES di Cloud SQL per MySQL
restituisce le impostazioni per la sessione corrente:
SHOW SESSION VARIABLES LIKE '%collation%';
= utf8_general_ci
|
ROWID |
Oracle assegna a ogni riga di una tabella un valore ROWID univoco per identificare la riga della tabella. ROWID è l'indirizzo della riga che contiene il numero dell'oggetto dati, il blocco dati della riga, la posizione della riga e il file di dati. |
Parzialmente | N/A |
ROW_NUMBER() è disponibile a partire da MySQL 8.0. Se utilizzi una versione precedente, emula la stessa funzionalità utilizzando una variabile di sessione @row_number. |
ROWNUM |
Restituisce un numero che rappresenta l'ordine con cui una riga viene restituita da una tabella Oracle | Parzialmente | N/A | ROW_NUMBER() è disponibile a partire da MySQL 8.0. Se utilizzi una versione precedente, emula la stessa funzionalità utilizzando una variabile di sessione @row_number. |
La tabella seguente descrive dove le funzioni (gruppo) di Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità, mentre è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
AVG |
Restituisce il valore medio di una colonna o di un'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 di una colonna o di un'espressione | Sì | Equivalente a Oracle | |
MIN |
Restituisce il valore minimo di una colonna o di un'espressione | Sì | MIN |
Equivalente a Oracle |
SUM |
Restituisce la somma di un valore di una colonna o di un'espressione | Sì | SUM |
Equivalente a Oracle |
LISTAGG |
Ordina i dati all'interno di ciascun gruppo specificato nella clausola ORDER BY
e concatena i valori della colonna di misurazione:
SELECT LISTAGG(
DEPARTMENT_NAME, ', ')
WITHIN GROUP
(ORDER BY DEPARTMENT_NAME) DEPT
FROM DEPARTMENTS;
-- Single line results
= Accounting, Administration, Benefits, Construction
|
Richiede una sintassi e un nome della funzione diversi |
GROUP_
CONCAT
|
Utilizza la funzione GROUP_CONCAT di Cloud SQL per MySQL per restituire
risultati equivalenti:
SELECT GROUP_CONCAT(
DEPARTMENT_NAME ORDER BY DEPARTMENT_NAME SEPARATOR ', ') DEPT
FROM DEPARTMENTS;
-- Single line results
= Accounting, Administration, Benefits, Construction
|
La tabella seguente descrive dove la funzione FETCH di Oracle e Cloud SQL per MySQL
è equivalenti per nome e funzionalità.
| Funzione Oracle | Implementazione di Oracle | Equivalente Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
FETCH |
Recupera un numero specificato di righe dal set di risultati di una query su più righe:
SELECT * FROM
EMPLOYEES
FETCH FIRST 10 ROWS ONLY;
|
Sì | LIMIT |
Utilizza la clausola MySQL LIMIT per recuperare le righe da una query:
SELECT * FROM
EMPLOYEES
LIMIT 10;
|
Filtri, operatori e sottoquery di base
I filtri di base, le funzioni degli operatori e le sottoquery sono relativamente semplici da convertire, con uno sforzo minimo richiesto. La maggior parte degli sforzi riguarda la conversione dei formati della data, poiché Oracle e Cloud SQL per MySQL utilizzano formati di data predefiniti diversi:
- Per impostazione predefinita, la funzione Oracle
SYSDATErestituisce questo formato:01-AUG-19. - Per impostazione predefinita, la funzione
SYSDATE()di Cloud SQL per MySQL restituisce questo formato:2019-08-01 12:04:05.
Per impostare i formati di data e ora, utilizza le funzioni MySQL DATE_FORMAT o STR_TO_DATE.
La tabella seguente descrive dove i filtri di base, gli operatori e le funzioni di sottoquery di Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità, nonché dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente Cloud SQL per MySQL | Funzione Cloud SQL per MySQL |
|---|---|---|---|
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 MySQL supporta le sottoquery nella clausola SELECT, nella clausola JOIN e per l'applicazione di 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 MySQL supporta tutti gli operatori di base:> | >= | < | <= | = | <> | !=
|
Best practice per le query di Cloud SQL per MySQL
Per mantenere livelli di prestazioni paragonabili tra Cloud SQL per MySQL e Oracle, potrebbe essere necessario ottimizzare le query. Queste ottimizzazioni includono la modifica delle strutture dell'indice e la regolazione dello schema del database. Questa sezione fornisce alcune linee guida per aiutarti a ottenere prestazioni delle query paragonabili su Cloud SQL per MySQL.
Crea un indice in cluster
Quando utilizzi il motore di archiviazione InnoDB, una best practice consiste nel definire una tabella con una chiave primaria, poiché questa chiave crea un indice in cluster su quella tabella. Oltre a migliorare le prestazioni delle query, questo approccio consente anche di creare indici secondari aggiuntivi. Tuttavia, vuoi evitare di creare troppi indici. La presenza di indici ridondanti non migliora le prestazioni e può rallentare l'esecuzione di DML. Questa best practice porta a una seconda best practice: monitorare regolarmente gli indici ridondanti ed eliminarli dal database, se ne sono presenti di ridondanti.
Utilizza la seguente query per identificare le tabelle senza chiavi primarie in modo da poter creare chiavi primarie per loro:
mysql> SELECT t.table_schema, t.table_name
FROM information_schema.tables t LEFT JOIN
information_schema.statistics s
ON t.table_schema=s.table_schema AND t.table_name=s.table_name
AND s.non_unique=0
WHERE s.table_name IS NULL
AND t.table_schema NOT IN('sys', 'information_schema', 'mysql',
'performance_schema')
AND t.`TABLE_TYPE` <> 'VIEW';
Utilizza la seguente query per trovare tabelle senza indici, in modo da poter creare indici per esse:
mysql> SELECT t.table_schema, t.table_name FROM INFORMATION_SCHEMA.tables t
WHERE table_name NOT IN
(SELECT table_name FROM (
SELECT table_name, index_name
FROM information_schema.statistics
GROUP BY table_name, index_name) tab_ind_cols
GROUP BY table_name)
AND table_schema NOT IN('sys', 'information_schema', 'mysql', 'performance_schema')
AND TABLE_TYPE <> 'VIEW';
Utilizza la seguente query per verificare la presenza di indici ridondanti in modo da poter rimuovere le ridondanze:
mysql> SELECT * FROM sys.schema_redundant_indexes;
Modificare parametri di ricerca
Per ottimizzare le prestazioni delle query, potrebbe essere necessario modificare i parametri di sessione. Cloud SQL per MySQL include un insieme di flag che puoi modificare a questo scopo, inclusi i seguenti flag:
- Parametri correlati a InnoDB
SORTparametriJOINparametri- Parametri di gestione della cache
Monitoraggio delle query
L'esecuzione lenta delle query può causare l'interruzione della risposta del sistema o altri colli di bottiglia, perciò è importante monitorare regolarmente le query.
Esistono diversi modi per diagnosticare le istruzioni SQL a esecuzione lenta:
- Utilizza la dashboard di Cloud SQL per MySQL per insight storici e in tempo reale sulle query con esecuzione lenta.
- Utilizza Cloud Monitoring per monitorare il log delle query lente di Cloud SQL per MySQL.
Utilizza la visualizzazione
statement_analysisdi Cloud SQL per MySQL per visualizzare le statistiche di runtime su un'istruzione SQL:mysql> SELECT * FROM sys.statement_analysis;
Analizzare le query Cloud SQL per MySQL
Lo strumento di ottimizzazione delle query in Cloud SQL per MySQL genera un piano di esecuzione per le istruzioni SELECT, INSERT, UPDATE e DELETE. Questi piani sono utili quando modifichi una query eseguita lentamente. Ci sono alcune considerazioni da
tenere a mente:
- I piani di esecuzione non sono oggetti di database di cui è necessario eseguire la migrazione, ma piuttosto uno strumento per analizzare le differenze di prestazioni tra Oracle e Cloud SQL per MySQL che eseguono la stessa istruzione su set di dati identici.
- Cloud SQL per MySQL non supporta la stessa sintassi, funzionalità o output del piano di esecuzione di Oracle.
Ecco un piano di esempio per illustrare le differenze tra un piano di esecuzione Oracle e un piano di esecuzione di Cloud SQL per MySQL:
SQL> EXPLAIN PLAN FOR
SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 105;
SQL> SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY (FORMAT=>'ALL +OUTLINE'));
Plan hash value: 1833546154
---------------------------------------------------------------------------------------------
| Id | Operation | Name | Rows | Bytes | Cost (%CPU)| Time |
---------------------------------------------------------------------------------------------
| 0 | SELECT STATEMENT | | 1 | 69 | 1 (0)| 00:00:01 |
| 1 | TABLE ACCESS BY INDEX ROWID| EMPLOYEES | 1 | 69 | 1 (0)| 00:00:01 |
|* 2 | INDEX UNIQUE SCAN | EMP_EMP_ID_PK | 1 | | 0 (0)| 00:00:01 |
---------------------------------------------------------------------------------------------
mysql> EXPLAIN SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 105;
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
| 1 | SIMPLE | EMPLOYEES | NULL | const | PRIMARY | PRIMARY | 3 | const | 1 | 100.00 | NULL |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
Ottimizza le stored procedure e i trigger
A differenza di Oracle, le stored procedure e le funzioni di Cloud SQL per MySQL vengono analizzate a ogni esecuzione. Uno strumento utile per il benchmarking delle prestazioni delle procedure e delle funzioni archiviate è l'utilità BENCHMARK() MySQL.
Questo strumento accetta due parametri, un conteggio di iterazione e un'espressione, e stima il runtime dell'espressione specificata (ad esempio, stored procedure, funzione e istruzione SELECT). L'output rappresenta il runtime totale approssimativo
in tutte le iterazioni.
Di seguito è riportato un esempio per illustrare l'utilità BENCHMARK():
-- SELECT Expression Example
mysql> select benchmark(10000000, 'select sysdate()');
+-----------------------------------------+
| benchmark(10000000, 'select sysdate()') |
+-----------------------------------------+
| 0 |
+-----------------------------------------+
1 row in set (0.12 sec)
-- Result: Run time of 0.12 sec for 1,0000,000 iterations
-- FUNCTION Example
mysql> select benchmark(1000000, func1());
+-----------------------------+
| benchmark(1000000, func1()) |
+-----------------------------+
| 0 |
+-----------------------------+
1 row in set (2.54 sec)
-- Result: Run time of 2.54 sec for 1,000,000 iterations
Se noti una regressione delle prestazioni durante la conversione, utilizza il comando
MySQL EXPLAIN per identificare i possibili fattori che contribuiscono alla regressione. Una soluzione comune per prestazioni lente è modificare la struttura di un indice delle tabelle per adattare l'ottimizzatore MySQL. Un'altra pratica comune consiste nell'ottimizzare un codice PL/SQL convertito riducendo il recupero dei dati non necessario o utilizzando tabelle temporanee all'interno del codice procedurale MySQL.
Passaggi successivi
- Scopri di più sugli account utente MySQL.
- Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Dai un'occhiata al nostro Cloud Architecture Center.