Questo documento illustra le differenze di base tra le query di Oracle® e Cloud SQL per MySQL e come le funzionalità di Oracle vengono mappate alle funzionalità di Cloud SQL per MySQL. Vengono inoltre descritti i fattori che influiscono sulle prestazioni di Cloud SQL per MySQL e i modi per analizzare e ottimizzare le prestazioni delle query su Google Cloud. Sebbene questo documento descriva le tecniche per ottimizzare le stored procedure e gli trigger per Cloud SQL per MySQL, non illustra come tradurre il codice PL/SQL in funzioni e stored procedure MySQL.
Quando converti le query da Oracle Database a Cloud SQL per MySQL, devono essere prese in considerazione alcune differenze di dialetto SQL. Esistono inoltre diverse funzioni predefinite diverse o incompatibili tra le due piattaforme di database.
Differenze nelle query di base
Sebbene sia Oracle sia Cloud SQL per MySQL supportino ANSI SQL, esistono diverse differenze fondamentali quando esegui query sui dati, principalmente per quanto riguarda l'utilizzo delle funzioni di sistema.
La seguente tabella evidenzia le differenze nella sintassi di SELECT e FROM per Oracle e Cloud SQL per MySQL.
| Nome della funzionalità Oracle | Implementazione di Oracle | Assistenza Cloud SQL per MySQL | Equivalente di Cloud SQL per MySQL |
|---|---|---|---|
| Sintassi di base di SQL per il recupero dei dati |
SELECTFROMWHEREGROUP BYHAVINGORDER BY
|
Sì |
SELECTFROMWHEREGROUP BYHAVINGORDER BY
|
SELECT
per la stampa dell'output |
SELECT 1 FROM DUAL
|
Sì |
SELECT 1o SELECT 1 FROM DUAL
|
| Alias di colonna | SELECT COL1 AS C1
|
Sì |
SELECT COL1 AS C1o 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
ORDERS) |
No | Sensibile alle maiuscole in base al nome della tabella definito (ad esempio il nome della tabella può essere solo orders o ORDERS) |
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 i calcoli composti o eliminando le operazioni di join, nonché a condensare più query separate in un'unica query semplificata.
L'esempio seguente illustra una conversione da Oracle 11g/12c a Cloud SQL per MySQL per una visualizzazione 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 vista funzionante 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.
Le unioni Cloud SQL per MySQL supportano l'utilizzo di una sintassi alternativa, ad esempio la clausola USING, la clausola WHERE anziché la clausola ON e SUBQUERY nell'istruzione JOIN.
La tabella seguente mostra un esempio di conversione JOIN.
Tipo di JOIN Oracle |
Assistenza 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 la possibilità di utilizzare 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 sia le funzioni UNION sia UNION ALL,
non supporta le funzioni INTERSECT e MINUS di Oracle:
UNIONcollega i set di risultati di due istruzioniSELECTdopo eliminare i record duplicati.UNION ALLcollega gli insiemi di risultati di due istruzioniSELECTsenza eliminare i record duplicati.INTERSECTrestituisce l'intersezione di due istruzioniSELECTsolo se esiste un record nei set di risultati di entrambe le query.MINUSconfronta due o più istruzioniSELECT, restituendo solo le righe distinte della prima query che non vengono restituite dalla seconda query.
La tabella seguente mostra alcuni esempi di conversione da Oracle a Cloud SQL per MySQL.
| Funzione Oracle | Implementazione di Oracle | Assistenza Cloud SQL per MySQL | Equivalente di 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 ampio elenco di funzioni scalari (una riga) e di aggregazione. Alcune delle funzioni di Cloud SQL per MySQL sono simili alle loro controparti Oracle (per nome e funzionalità o con un nome diverso, ma con funzionalità simili). Sebbene alcune funzioni di Cloud SQL per MySQL possano avere nomi identici alle relative controparti Oracle, possono anche avere funzionalità diverse.
La tabella seguente descrive dove le funzioni di caratteri di Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità e dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente di Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
CONCAT |
Restituisce la prima stringa concatenata alla 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 in minuscolo o in maiuscolo:LOWER('SQL') = sql
|
Sì | LOWER o UPPER |
LOWER('SQL') = sql |
LPAD/RPAD |
Restituisce expression1, con spaziatura a sinistra o a destra per un totale di 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 posizionex (in questo caso 3), con una lunghezza diy. 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 |
Taglia i caratteri iniziali o finali (o entrambi) di 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 che compaiono nella ricerca:
LTRIM(' MySQL', ' ')
= MySQL
|
Parzialmente | LTRIM or RTRIM |
Le funzioni LTRIM e RTRIM di Oracle accettano un secondo parametro che specifica i caratteri iniziali o finali da rimuovere dalla stringa. Le funzioni Cloud SQL per MySQL rimuovono solo gli spazi iniziali e finali dalla stringa specificata:
LTRIM(' MySQL')
= MySQL
|
ASCII |
Prende 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, ovvero un valore numerico compreso tra 0 e 225,
a un carattere:CHR(65) = A
|
Richiede un nome di funzione diverso | CHAR |
Cloud SQL per MySQL utilizza la funzione CHAR per la stessa
funzionalità, quindi devi modificare il nome della funzione:CHAR(65) = A
|
LENGTH |
Restituisce la lunghezza di una determinata stringa:LENGTH('MySQL') = 5
|
Sì | LENGTH |
LENGTH('MySQL') = 5 |
REGEXP_REPLACE |
Cerca un pattern di espressione regolare in una stringa: REGEXP_REPLACE('John', '[hn].', 'e') = Joe
|
No | N/D | Supportato a partire dalla versione 8 di MySQL. Come soluzione alternativa, utilizza la funzione REPLACE, se possibile, o sposta la logica nel livello di applicazione. |
REGEXP_SUBSTR |
Espande la funzionalità della funzione SUBSTR cercando
in una stringa un pattern di espressioni regolari:
REGEXP_SUBSTR('https://console.cloud.google.com/sql/instances','https://([[:alnum:]]+\.?){3,4}/?')
=
https://console.cloud.google.com/
|
No | N/D | Supportato a partire dalla versione 8 di MySQL. Come soluzione alternativa, utilizza la funzione SUBSTR, se possibile, o sposta la logica nel livello di applicazione. |
REGEXP_COUNT |
Restituisce il numero di volte in cui un pattern si verifica in una stringa di origine | No | N/D | Nessuna funzione equivalente disponibile per Cloud SQL per MySQL. Sposta questa logica nel livello di applicazione. |
REGEXP_INSTR |
Cerca un pattern di espressioni regolari in una posizione (indice) di una stringa | No | N/D | Supportato a partire dalla versione 8 di MySQL. Se utilizzi una versione precedente, sposta questa logica nel livello di applicazione. |
REVERSE |
Restituisce la stringa invertita di 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 di Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
ABS |
Restituisce il valore assoluto di un determinato numero: ABS(-4.6) = 4.6 |
Sì | ABS |
ABS(-4.6) = 4.6 |
CEIL |
Restituisce il numero intero più piccolo maggiore o uguale al numero fornito: CEIL(21.4) = 22 |
Sì | CEIL |
CEIL(21.4) = 22 |
FLOOR |
Restituisce il numero intero più grande uguale o minore al numero specificato: FLOOR(-23.7) = -24
|
Sì | FLOOR |
FLOOR(-23.7) = -24 |
MOD |
Restituisce il resto della divisione di m per
n:MOD(10, 3) = 1
|
Sì | MOD |
MOD(10, 3) = 1 |
ROUND |
Restituisce n arrotondato a posizioni intere a destra della virgola 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 di 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 MySQLdatetime sono equivalenti per nome e funzionalità e dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente di 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 risiede il
server di database:
SELECT SYSDATE
FROM DUAL;
= 31-JUL-2019
|
Sì | SYSDATE() |
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 di 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 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 da quello 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ù i mesi interi:
ADD_MONTHS(SYSDATE, 1)
= 31-JAN-19
|
Richiede un nome di 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 data) |
Restituisce il valore di un campo datetime in base a un'espressione
dell'intervallo:
EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019
|
Sì | EXTRACT (parte data) |
EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019
|
LAST_DAY |
Restituisce l'ultimo giorno del mese di 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 da quello 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 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 (formattata 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 di funzione diverso | DATE_FORMAT |
La funzione DATE_FORMAT di Cloud SQL per MySQL formatta un valore della 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 di Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
DECODE |
Confronta l'espressione con ciascun 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 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 supportata |
ORA_HASH |
Calcola un valore hash per una determinata 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à e dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente di Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
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 |
Modifica in base al fatto che sia richiesta una conversione esplicita o implicita:
CAST('1' AS SIGNED) + 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 MySQL richiede alcuni aggiustamenti alla sintassi e ai parametri:
CONVERT(
'Ä Ê Í A B C ' USING utf8)
= Ä Ê Í A B C
|
TO_CHAR (stringa/numerico) |
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 cifra 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 di funzione diverso | STR_TO_DATE |
La funzione STR_TO_DATE di Cloud SQL per MySQL accetta una stringa e restituisce una data in base a un 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 di funzione diverso | CAST |
Utilizza la funzione CAST di Cloud SQL per MySQL per restituire lo stesso risultato della funzione TO_NUMBER di 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 di Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
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 |
Oltre alla funzione CASE, Cloud SQL per MySQL supporta l'utilizzo del controllo 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 di Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
COALESCE |
Restituisce la prima espressione non null nell'elenco di espressioni:
COALESCE(
null, '1', 'a')
= a
|
Sì | COALESCE |
COALESCE(
null, '1', 'a')
= 1
|
NULLIF |
Esegui 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 in base al fatto che un'espressione sia null o non null | No | CASE |
L'istruzione CASE
sceglie tra 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 ambiente e identificatore di Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità e dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente di 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/D | N/D |
USER |
Restituisce il nome utente dell'utente connesso 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 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 | N/D |
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 in cui una riga viene restituita da una tabella Oracle | Parzialmente | N/D | 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 aggregate (di gruppo) di Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità e dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente di Cloud SQL per MySQL | Funzione Cloud SQL per MySQL | Implementazione di Cloud SQL per MySQL |
|---|---|---|---|---|
AVG |
Restituisce il valore medio di una colonna o 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 un'espressione | Sì | Equivalente a Oracle | |
MIN |
Restituisce il valore minimo di una colonna o 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 della misura:
SELECT LISTAGG(
DEPARTMENT_NAME, ', ')
WITHIN GROUP
(ORDER BY DEPARTMENT_NAME) DEPT
FROM DEPARTMENTS;
-- Single line results
= Accounting, Administration, Benefits, Construction
|
Richiede un nome e una sintassi 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 è equivalente per nome e funzionalità.
| Funzione Oracle | Implementazione di Oracle | Equivalente di 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 con più righe:
SELECT * FROM
EMPLOYEES
FETCH FIRST 10 ROWS ONLY;
|
Sì | LIMIT |
Utilizza la clausola LIMIT
MySQL per recuperare 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 facili da convertire, con un impegno minimo. La maggior parte dell'impegno gira intorno alla conversione dei formati di data perché Oracle e Cloud SQL per MySQL utilizzano formati di data predefiniti diversi:
- Per impostazione predefinita, la funzione
SYSDATEdi Oracle restituisce 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 le funzioni di filtro, gli operatori e le sottoquery di base di Oracle e Cloud SQL per MySQL sono equivalenti per nome e funzionalità e dove è consigliata una conversione.
| Funzione Oracle | Implementazione di Oracle | Equivalente di 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 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 MySQL supporta tutti gli operatori di base:> | >= | < | <= | = | <> | !=
|
Best practice per le query 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 degli indici e l'aggiustamento dello schema del database. Questa sezione fornisce alcune linee guida per aiutarti a ottenere prestazioni di query paragonabili su Cloud SQL per MySQL.
Crea un indice cluster
Quando utilizzi il motore di archiviazione InnoDB, una best practice è definire una tabella con una chiave primaria, perché questa chiave crea un indice cluster su quella tabella. Oltre a migliorare le prestazioni delle query, questo approccio consente anche di creare ulteriori indici secondari. Tuttavia, è meglio 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: monitora regolarmente la presenza di indici ridondanti e, se ne hai, rimuovili dal database.
Utilizza la seguente query per identificare le tabelle senza chiavi primarie in modo da poter creare chiavi primarie per queste tabelle:
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 le tabelle che non hanno indici in modo da poterli creare:
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 poterli rimuovere:
mysql> SELECT * FROM sys.schema_redundant_indexes;
Modificare parametri di ricerca
Per ottimizzare il rendimento delle query, potrebbe essere necessario modificare i parametri della sessione. Cloud SQL per MySQL dispone di un insieme di flag che puoi modificare per questo scopo, inclusi i seguenti flag:
- Parametri relativi a InnoDB
- Parametri
SORT - Parametri
JOIN - Parametri di gestione della cache
Monitorare le query
Le query con esecuzione lenta possono causare l'interruzione della risposta del sistema o altri colli di bottiglia, pertanto è importante monitorarle regolarmente.
Esistono diversi modi per diagnosticare le istruzioni SQL con esecuzione lenta:
- Utilizza la dashboard Cloud SQL per MySQL per informazioni storiche e in tempo reale sulle query con esecuzione lenta.
- Utilizza Monitoraggio cloud 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 relative a un'istruzione SQL:mysql> SELECT * FROM sys.statement_analysis;
Analizzare le query di Cloud SQL per MySQL
L'ottimizzatore 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 che viene eseguita lentamente. È necessario prendere in considerazioni alcuni fattori, come:
- 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 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 di 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 gli attivatori
A differenza di Oracle, le funzioni e le stored procedure di Cloud SQL per MySQL vengono analizzate a ogni esecuzione. Uno strumento utile per il benchmarking delle prestazioni delle stored procedure e delle funzioni è l'utilità BENCHMARK() di MySQL.
Questo strumento accetta due parametri, un conteggio di iterazioni e un'espressione, e stima il tempo di esecuzione dell'espressione specificata (ad esempio, stored procedure, funzione e istruzione SELECT). L'output rappresenta il runtime totale approssimativo di tutte le iterazioni.
Di seguito è riportato un esempio che illustra 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 del rendimento durante la conversione, utilizza il
comando MySQL EXPLAIN
per identificare i possibili fattori che contribuiscono alla regressione. Una soluzione comune per le prestazioni lente è modificare la struttura dell'indice di una tabella in modo da adattarla all'ottimizzatore di MySQL. Un'altra pratica comune è ottimizzare un codice PL/SQL convertito riducendo il recupero di dati non necessari o utilizzando tabelle temporanee all'interno del codice procedurale MySQL.
Passaggi successivi
- Scopri di più sugli account utente MySQL.
- Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Consulta il nostro Cloud Architecture Center.