Questo documento illustra le differenze di base nelle query tra Oracle® e Cloud SQL per MySQL e la mappatura delle funzionalità in Oracle alle funzionalità in 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. Questo documento illustra le tecniche per ottimizzare le risorse di procedure e trigger per Cloud SQL per MySQL, non spiega come tradurre il codice PL/SQL in stored procedure e funzioni MySQL.
Durante la conversione delle query da database Oracle a Cloud SQL per MySQL, devi considerare alcune differenze di dialetto SQL. Esistono anche diversi modelli a funzioni 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 funzionalità Oracle | Implementazione Oracle | Supporto per 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 | 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 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 distinte 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 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
Oracle
partecipa
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 di JOIN.
Tipo 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:
UNIONcongiunge i set di risultati di due istruzioniSELECTdopo eliminare i record duplicati.UNION ALLallega i set di risultati di due istruzioniSELECTsenza eliminando 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 seguente tabella mostra alcuni esempi di conversione da Oracle a Cloud SQL per MySQL.
| Funzione Oracle | Implementazione Oracle | Supporto per 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 funzioni di Cloud SQL per MySQL sono simili alle rispettive controparti Oracle (per nome e funzionalità o in base a 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 Oracle e Cloud SQL per MySQL funzioni carattere sono equivalenti per nome e funzionalità, e dove una la conversione è consigliata.
| 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 minuscole 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 posizione
x (in questo caso 3), con una lunghezza di
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 in cui ogni occorrenza di una stringa di ricerca viene sostituita con un
stringa sostitutiva:
REPLACE('ORADB', 'ORA', 'MySQL')
= MySQLDB
|
Sì | REPLACE |
REPLACE('ORADB', 'ORA', 'MySQL')
= MySQLDB
|
TRIM |
Taglia 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 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 lo stesso
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 in una stringa un pattern di espressioni regolari: 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 il comando
SUBSTR, se possibile, o spostare la logica nella
livello di applicazione |
REGEXP_COUNT |
Restituisce il numero di volte in cui un pattern compare in una stringa di origine | No | N/D | Nessuna funzione equivalente disponibile per Cloud SQL per MySQL. Sposta questo la logica al livello dell'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 in il livello dell'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 valore
numero: 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 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 la seconda
è 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 valore datetime diverso
formato. 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 DATE_FORMAT()
personalizzata.
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 valore datetime diverso
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 specificatedate1 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 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 Oracle e Cloud SQL per MySQL le funzioni di conversione sono equivalenti per nome e funzionalità. Inoltre, laddove una la conversione è consigliata.
| 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 valore con tipo di raccolta:
CAST('1' as int) + 1
= 2
|
Parzialmente | CAST |
Apporta le modifiche necessarie a seconda che sia necessaria 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 della sintassi e dei 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
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 |
Cloud SQL per MySQL
La funzione STR_TO_DATE 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 Oracle e Cloud SQL per MySQL
le funzioni condizionali di SELECT sono equivalenti per nome e funzionalità e
in cui è 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 tra una sequenza di condizioni e
esegue un'istruzione corrispondente con la seguente sintassi:
CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END
|
Sì | CASE |
Oltre alla funzione CASE, Cloud SQL per MySQL
supporta l'uso di IF/ELSE
gestione condizionale 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 |
Esegue un confronto tra expression1 e
expression2. Se
uguale, 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 globale (valore RAW)
formata da 16 byte:
SELECT SYS_GUID()
FROM DUAL
=
8EFA4A31468B4C6DE05011AC0200009E
|
No | REPLACE e UUID |
Come soluzione alternativa, utilizza i REPLACE e
UUID funzioni per simulare SYS_GUID
funzione:
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 la
nome utente e nome host (root@IP_ADDRESS) per
connessione. Per recuperare solo il nome utente, utilizza l'apposito supporto aggiuntivo
funzioni:
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
|
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 da identificare
nella riga della tabella. ROWID è l'indirizzo della riga
che contiene il numero dell'oggetto dati, il blocco di dati della riga, la riga
la posizione originale 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
con una versione precedente, emula la stessa funzionalità con un
variabile di sessione @row_number. |
La tabella seguente descrive dove Oracle e Cloud SQL per MySQL le funzioni aggregate (gruppo) sono equivalenti per nome e funzionalità e dove si consiglia 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 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 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 ogni 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 diversi per la funzione |
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 Oracle e Cloud SQL per MySQL FETCH
è 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 |
Utilizzare 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 semplice da convertire, con uno sforzo nominale richiesto. Gran parte dell'impegno ruota intorno alla conversione dei formati di data, poiché Oracle e Cloud SQL per MySQL utilizza diversi formati di data predefiniti:
- Per impostazione predefinita, la funzione
SYSDATEdi Oracle restituisce questo formato:01-AUG-19. - La funzione
SYSDATE()di Cloud SQL per MySQL restituisce questo formato: predefinita:2019-08-01 12:04:05.
Per impostare i formati di data e ora, utilizza MySQL
DATE_FORMAT
o il
STR_TO_DATE
funzioni.
La tabella seguente descrive dove Oracle e Cloud SQL per MySQL di base filtri, operatori e funzioni di sottoquery sono equivalenti per nome e 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 in SELECT
della clausola JOIN, oltre che per l'applicazione di filtri nella clausola
WHERE/AND clausole:
-- SELECT Subquery
SELECT D.DEPARTMENT_NAME,
(SELECT AVG(SALARY) AS AVG_SAL
FROM EMPLOYEES E
WHERE E.DEPARTMENT_ID =
D.DEPARTMENT_ID) AVG_SAL
FROM DEPARTMENTS D;
-- JOIN Subquery
SELECT FIRST_NAME, LAST_NAME, SALARY
FROM EMPLOYEES E JOIN
(SELECT *
FROM DEPARTMENTS
WHERE LOCATION_ID = 2700) D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
-- Filtering Subquery
SELECT FIRST_NAME,
LAST_NAME,
SALARY
FROM EMPLOYEES
WHERE SALARY < (SELECT AVG(SALARY)
FROM EMPLOYEES);
|
| Operatori | Sì | Operatori | Cloud SQL per MySQL supporta tutti gli operatori di base:> | >= | < | <= | = | <> | !=
|
Best practice per le query Cloud SQL per MySQL
Per mantenere livelli di prestazioni comparabili tra Cloud SQL per MySQL e Oracle, potresti aver bisogno di ottimizzare le tue query. Queste ottimizzazioni includono modificare le strutture degli indici e lo schema del database. Questa sezione fornisce alcune linee guida per aiutarti a ottenere prestazioni comparabili delle query 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, perché questa chiave crea un indice in cluster sulla tabella. Oltre a migliorare le prestazioni delle query, questo approccio ti consente anche di creare ulteriori indici secondari. Tuttavia, è meglio evitare di creare troppi indici. I dati sono ridondanti indici non migliorano le prestazioni e possono rallentare DML dell'esecuzione. Questa best practice porta a una seconda best practice: il monitoraggio regolare per gli indici ridondanti e, se ce ne sono di ridondanti, eliminali dalla per configurare un database.
Utilizza la seguente query per identificare le tabelle senza chiavi primarie in modo da poter crea chiavi primarie:
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 i parametri di query
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 a questo scopo, inclusi i seguenti:
- Parametri relativi a InnoDB
- Parametri
SORT - Parametri
JOIN - Parametri di gestione della cache
Monitora le query
Le query eseguite lentamente possono 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 con esecuzione lenta:
- Utilizza la Dashboard di Cloud SQL per MySQL per insight storici e in tempo reale sulle query eseguite lentamente.
- Utilizza Monitoraggio cloud per monitorare il log delle query lente di Cloud SQL per MySQL.
Utilizza la vista Cloud SQL per MySQL
statement_analysisper vedere statistiche di runtime su 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 eseguita lentamente. È necessario prendere in considerazioni alcuni fattori, come:
- I piani di esecuzione non sono oggetti di database di cui è necessario eseguire la migrazione; ma sono uno strumento per analizzare le differenze di rendimento Oracle e Cloud SQL per MySQL che eseguono la stessa istruzione su istanze e dei set di dati.
- 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
le prestazioni di procedure e funzioni sono
Utility MySQL BENCHMARK().
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 totale approssimativo
il runtime su 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 delle prestazioni durante la conversione, utilizza il metodo
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 file PL/SQL convertito
riducendo il recupero di dati non necessario o utilizzando tabelle temporanee all'interno
il codice procedurale MySQL.
Passaggi successivi
- Scopri di più su MySQL account utente.
- Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Dai un'occhiata al nostro Centro architetture cloud.