Ce document décrit les différences entre les requêtes de base Oracle® et Cloud SQL pour MySQL, ainsi que la correspondance entre les fonctionnalités Oracle et celles de Cloud SQL pour MySQL. Il décrit également les considérations de performances pour Cloud SQL pour MySQL, ainsi que les méthodes d'analyse et d'optimisation des performances des requêtes sur Google Cloud. Bien que ce document aborde les techniques d'optimisation des procédures et des déclencheurs stockés pour Cloud SQL pour MySQL, il ne décrit pas comment traduire le code PL/SQL en procédures et fonctions stockées MySQL.
Lorsque vous convertissez des requêtes de base de données Oracle vers Cloud SQL pour MySQL, vous devez prendre en compte certaines différences dans le langage SQL. Il existe également plusieurs fonctions intégrées qui sont différentes ou incompatibles entre les deux plates-formes de base de données.
Différences des requêtes de base
Bien qu'Oracle et Cloud SQL pour MySQL soient toutes deux compatibles avec ANSI SQL, il existe plusieurs différences essentielles dans l'interrogation des données, principalement liées à l'utilisation des fonctions système.
Le tableau suivant met en évidence les différences de syntaxe SELECT et FROM pour Oracle et Cloud SQL pour MySQL.
| Nom de la fonctionnalité Oracle | Mise en œuvre dans Oracle | Compatibilité avec Cloud SQL pour MySQL | Équivalent Cloud SQL pour MySQL |
|---|---|---|---|
| Syntaxe de base SQL pour la récupération de données |
SELECTFROMWHEREGROUP BYHAVINGORDER BY
|
Oui |
SELECTFROMWHEREGROUP BYHAVINGORDER BY
|
SELECT pour l'impression en sortie |
SELECT 1 FROM DUAL
|
Oui |
SELECT 1ou SELECT 1 FROM DUAL
|
| Alias de colonne | SELECT COL1 AS C1
|
Oui |
SELECT COL1 AS C1ou SELECT COL1 C1 |
| Sensibilité à la casse des noms de table | Non sensible à la casse (par exemple, le nom de la table peut être orders et ORDERS) |
Non | Sensibilité à la casse en fonction du nom de table défini (par exemple, le nom de la table ne peut être que orders ou ORDERS) |
Vues intégrées
Les vues intégrées (également appelées tables dérivées) sont des instructions SELECT situées dans la clause FROM et utilisées en tant que sous-requête. Les vues intégrées peuvent simplifier les requêtes complexes en supprimant les calculs composés ou en éliminant les opérations de jointure, tout en regroupant plusieurs requêtes distinctes en une seule requête simplifiée.
L'exemple suivant présente un exemple de conversion depuis Oracle 11g/12c vers Cloud SQL pour MySQL pour une vue intégrée.
Une vue intégrée dans Oracle 11g/12c :
SELECT FIRST_NAME,
DEPARTMENT_ID,
SALARY,
DATE_COL
FROM EMPLOYEES,
(SELECT SYSDATE AS DATE_COL FROM DUAL);
Une vue de travail dans Cloud SQL pour MySQL 5.7 avec un alias :
SELECT FIRST_NAME,
DEPARTMENT_ID,
SALARY,
DATE_COL
FROM EMPLOYEES, (SELECT SYSDATE() AS DATE_COL FROM DUAL) AS A1;
Jointures
Les types de jointure d'Oracle sont compatibles avec Cloud SQL pour MySQL, à l'exception de FULL JOIN.
Les jointures Cloud SQL pour MySQL sont compatibles avec l'utilisation d'une syntaxe alternative, telle que la clause USING, la clause WHERE au lieu de la clause ON et SUBQUERY dans l'instruction JOIN.
Le tableau suivant présente un exemple de conversion de JOIN.
Type de JOIN Oracle |
Compatibilité avec Cloud SQL pour MySQL | Syntaxe JOIN dans Cloud SQL pour MySQL |
|---|---|---|
INNER JOIN |
Oui |
SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
|
CROSS JOIN |
Oui |
SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E CROSS JOIN DEPARTMENTS D
|
FULL JOIN |
Non | Songez à utiliser UNION avec LEFT et
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 ]
|
Oui |
SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E LEFT JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
|
RIGHT JOIN
[ OUTER ]
|
Oui |
SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E RIGHT JOIN DEPARTMENTS D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
|
SUBQUERY |
Oui |
SELECT E.FIRST_NAME, D.DEPARTMENT_NAME
FROM EMPLOYEES E JOIN (SELECT * FROM DEPARTMENTS)D
ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;
|
Bien que Cloud SQL pour MySQL soit compatible avec les fonctions UNION et UNION ALL, il n'est pas compatible avec les fonctions INTERSECT et MINUS d'Oracle :
UNIONassocie les ensembles de résultats de deux instructionsSELECTaprès avoir supprimé les enregistrements en double.UNION ALLassocie les ensembles de résultats de deux instructionsSELECTsans supprimer les enregistrements en double.INTERSECTrenvoie l'intersection de deux instructionsSELECT, uniquement si un enregistrement figure dans les ensembles de résultats des deux requêtes.MINUScompare deux instructionsSELECTou plus, et ne renvoie que des lignes distinctes de la première requête qui ne sont pas renvoyées par la deuxième requête.
Le tableau suivant présente quelques exemples de conversions Oracle vers Cloud SQL pour MySQL.
| Fonction Oracle | Mise en œuvre dans Oracle | Compatibilité avec Cloud SQL pour MySQL | Équivalent Cloud SQL pour MySQL |
|---|---|---|---|
UNION |
SELECT COL1 FROM TBL1UNIONSELECT COL1 FROM TBL2
|
Oui | SELECT COL1 FROM TBL1UNIONSELECT COL1 FROM TBL2
|
UNION ALL |
SELECT COL1 FROM TBL1UNION ALLSELECT COL1 FROM TBL2
|
Oui | SELECT COL1 FROM TBL1UNION ALLSELECT COL1 FROM TBL2
|
INTERSECT |
SELECT COL1 FROM TBL1INTERSECTSELECT COL1 FROM TBL2
|
Non |
SELECT COL1 FROM TBL1WHERE COL1 IN(SELECT COL1 FROM TBL2)
|
MINUS |
SELECT COL1 FROM TBL1MINUSSELECT COL1 FROM TBL2
|
Non | SELECT A.COL1
FROM TBL1 A LEFT JOIN TBL2 B
ON USING(COL1)
WHERE B.COL1 IS NULL
|
Fonctions scalaires et de groupe
Cloud SQL pour MySQL fournit une longue liste de fonctions scalaires (à une seule ligne) et d'agrégation. Certaines fonctions Cloud SQL pour MySQL sont similaires à leurs équivalents Oracle (nom et fonctionnalité identique, ou nom différent et fonctionnalité similaire). Bien que certaines fonctions Cloud SQL pour MySQL puissent avoir des noms identiques à leurs équivalents Oracle, elles peuvent également présenter des fonctionnalités différentes.
Le tableau suivant détaille les fonctions de caractères Oracle et Cloud SQL pour MySQL qui sont équivalentes par nom et fonctionnalité, et celles pour lesquelles une conversion est recommandée.
| Fonction Oracle | Mise en œuvre dans Oracle | Équivalent Cloud SQL pour MySQL | Fonction Cloud SQL pour MySQL | Mise en œuvre dans Cloud SQL pour MySQL |
|---|---|---|---|---|
CONCAT |
Renvoie la première chaîne concaténée avec la deuxième chaîne : CONCAT('A', 1) = A1 |
Oui | CONCAT |
CONCAT('A', 1) = A1 |
CONCAT USING PIPE |
FNAME |' '| LNAME |
Non | CONCAT |
CONCAT(FNAME, ' ', LNAME) |
LOWER ou UPPER |
Renvoie la chaîne avec toutes les lettres en minuscules ou en majuscules :LOWER('SQL') = sql |
Oui | LOWER ou UPPER |
LOWER('SQL') = sql |
LPAD/RPAD |
Renvoie expression1, complétée à gauche ou à droite jusqu'à une longueur de n caractères, avec la séquence de caractères dans expression2 :LPAD('A',3,'*') = **A |
Oui | LPAD ou RPAD |
LPAD('A',3,'*') = **A |
SUBSTR |
Renvoie une partie de la chaîne, commençant à la position x (dans ce cas 3), avec une longueur de y. La première position de la chaîne est 1.
SUBSTR('MySQL', 3, 3)
= SQL
|
Oui | SUBSTR |
SUBSTR('MySQL', 3, 3)
= SQL
|
INSTR |
Renvoie la position (index) d'une chaîne à partir d'une chaîne donnée :
INSTR('MySQL', 'y')
= 2
|
Oui | INSTR |
INSTR('MySQL', 'y')
= 2
|
REPLACE |
Renvoie une chaîne avec chaque occurrence d'une chaîne de recherche remplacée par une chaîne de remplacement :
REPLACE('ORADB', 'ORA', 'MySQL')
= MySQLDB
|
Oui | REPLACE |
REPLACE('ORADB', 'ORA', 'MySQL')
= MySQLDB
|
TRIM |
Coupe les caractères de début ou de fin (ou les deux) d'une chaîne :
TRIM(both '-' FROM '-MySQL-')
= MySQL
TRIM(' MySQL ')
= MySQL
|
Oui | TRIM |
TRIM(both '-' FROM '-MySQL-')
= MySQL
TRIM(' MySQL ')
= MySQL
|
LTRIM/RTRIM |
Supprime, à partir de la gauche ou de la droite d'une chaîne, tous les caractères qui apparaissent dans la recherche :
LTRIM(' MySQL', ' ')
= MySQL
|
En partie | LTRIM or RTRIM |
Les fonctions Oracle LTRIM et RTRIM utilisent un deuxième paramètre qui spécifie les caractères de début ou de fin à supprimer de la chaîne. Les fonctions Cloud SQL pour MySQL ne suppriment que les espaces de début et de fin de la chaîne donnée :
LTRIM(' MySQL')
= MySQL
|
ASCII |
Prend un seul caractère et renvoie son code ASCII numérique : ASCII('A') = 65 |
Oui | ASCII |
ASCII('A') = 65 |
CHR |
Renvoie la valeur du code ASCII, qui est une valeur numérique comprise entre 0 et 255, d'un caractère :CHR(65) = A |
Nécessite un nom de fonction différent | CHAR |
Cloud SQL pour MySQL utilise la fonction CHAR pour la même fonctionnalité. Vous devez donc modifier le nom de la fonction :CHAR(65) = A |
LENGTH |
Renvoie la longueur d'une chaîne donnée :LENGTH('MySQL') = 5 |
Oui | LENGTH |
LENGTH('MySQL') = 5 |
REGEXP_REPLACE |
Recherche un motif d'expression régulière dans une chaîne : REGEXP_REPLACE('John', '[hn].', 'e') = Joe |
Non | N/A | Compatible avec MySQL à partir de la version 8. Pour contourner ce problème, utilisez si possible la fonction REPLACE ou déplacez la logique vers la couche d'application. |
REGEXP_SUBSTR |
Étend la fonctionnalité de la fonction SUBSTR en recherchant un modèle d'expression régulière dans une chaîne :
REGEXP_SUBSTR('https://console.cloud.google.com/sql/instances','https://([[:alnum:]]+\.?){3,4}/?')
=
https://console.cloud.google.com/
|
Non | N/A | Compatible avec MySQL à partir de la version 8. Pour contourner ce problème, utilisez si possible la fonction SUBSTR ou déplacez la logique vers la couche d'application. |
REGEXP_COUNT |
Renvoie le nombre d'occurrences d'un motif dans une chaîne source | Non | N/A | Aucune fonction équivalente n'est disponible pour Cloud SQL pour MySQL. Déplacez cette logique vers la couche d'application. |
REGEXP_INSTR |
Rechercher une position de chaîne (index) pour un motif d'expression régulière | Non | N/A | Compatible avec MySQL à partir de la version 8. Si vous utilisez une ancienne version, déplacez cette logique vers la couche d'application. |
REVERSE |
Renvoie la chaîne inversée pour une chaîne donnée :
REVERSE('MySQL')
= LQSyM
|
Oui | REVERSE |
REVERSE('MySQL')
= LQSyM
|
Le tableau suivant détaille les fonctions numériques Oracle et Cloud SQL pour MySQL qui sont équivalentes par nom et fonctionnalité, et celles pour lesquelles une conversion est recommandée.
| Fonction Oracle | Mise en œuvre dans Oracle | Équivalent Cloud SQL pour MySQL | Fonction Cloud SQL pour MySQL | Mise en œuvre dans Cloud SQL pour MySQL |
|---|---|---|---|---|
ABS |
Renvoie la valeur absolue d'un nombre donné : ABS(-4.6) = 4.6 |
Oui | ABS |
ABS(-4.6) = 4.6 |
CEIL |
Renvoie le plus petit nombre entier supérieur ou égal au nombre donné : CEIL(21.4) = 22 |
Oui | CEIL |
CEIL(21.4) = 22 |
FLOOR |
Renvoie le plus grand nombre entier égal ou inférieur au nombre donné : FLOOR(-23.7) = -24 |
Oui | FLOOR |
FLOOR(-23.7) = -24 |
MOD |
Renvoie le reste de m divisé par n :MOD(10, 3) = 1 |
Oui | MOD |
MOD(10, 3) = 1 |
ROUND |
Renvoie n arrondi à un nombre entier de chiffres à droite de la virgule :ROUND(1.39, 1) = 1.4 |
Oui | ROUND |
ROUND(1.39, 1) = 1.4 |
TRUNC (nombre) |
Renvoie n1 tronqué à n2 décimales. Le deuxième paramètre est facultatif.
TRUNC(99.999) = 99
TRUNC(99.999, 0) = 99
|
Nécessite un nom de fonction différent | TRUNCATE (nombre) |
La fonction Cloud SQL pour MySQL a un nom différent et le deuxième paramètre est obligatoire. TRUNCATE(99.999, 0) = 99
|
Le tableau suivant décrit les fonctions datetime Oracle et Cloud SQL pour MySQL qui sont équivalentes par leur nom et leur fonctionnalité, et celles pour lesquelles une conversion est recommandée.
| Fonction Oracle | Mise en œuvre dans Oracle | Équivalent Cloud SQL pour MySQL | Fonction Cloud SQL pour MySQL | Mise en œuvre dans Cloud SQL pour MySQL |
|---|---|---|---|---|
SYSDATE |
Renvoie la date et l'heure actuelles définies pour le système d'exploitation sur lequel réside le serveur de base de données :
SELECT SYSDATE
FROM DUAL;
= 31-JUL-2019
|
Oui | SYSDATE() |
La fonction
SELECT SYSDATE()
FROM DUAL;
= 2019-01-31 10:01:01.0
Vous pouvez modifier le format |
SYSTIMESTAMP |
Renvoie la date du système, y compris les secondes fractionnelles et le fuseau horaire :
SELECT SYSTIMESTAMP FROM DUAL
= 01-JAN-19 07.37.11.622187000 AM +00:00
|
Nécessite un nom de fonction différent |
CURRENT_
TIMESTAMP
|
La fonction Cloud SQL pour MySQL renvoie un format datetime différent par défaut. Pour formater la sortie, utilisez la fonction DATE_FORMAT().
SELECT CURRENT_TIMESTAMP
FROM DUAL;
= 2019-01-31 06:55:07
|
LOCAL_
TIMESTAMP
|
Renvoie la date et l'heure actuelles au format TIMESTAMP :
SELECT LOCALTIMESTAMP
FROM DUAL
= 01-JAN-19 10.01.10.123456 PM
|
Renvoie un format datetime différent. |
LOCAL_
TIMESTAMP
|
La fonction Cloud SQL pour MySQL renvoie un format datetime différent du format par défaut pour Oracle. Pour formater la sortie, utilisez la fonction DATE_FORMAT().
SELECT LOCAL_TIMESTAMP
FROM DUAL
= 2019-01-01 10:01:01.0
|
CURRENT_DATE |
Renvoie la date actuelle :
SELECT CURRENT_DATE
FROM DUAL
= 31-JAN-19
|
Renvoie un format datetime différent. |
CURRENT_
DATE
|
La fonction Cloud SQL pour MySQL renvoie un format datetime différent. Pour formater la sortie, utilisez la fonction DATE_FORMAT().
SELECT CURRENT_DATE
FROM DUAL
= 2019-01-31
|
CURRENT_
TIMESTAMP
|
Renvoie la date et l'heure actuelles :
SELECT CURRENT_TIMESTAMP
FROM DUAL
= 31-JAN-19 06.54.35.543146 AM +00:00
|
Renvoie un format datetime différent. |
CURRENT_
TIMESTAMP
|
La fonction Cloud SQL pour MySQL renvoie un format datetime différent. Pour formater la sortie, utilisez la fonction DATE_FORMAT().
SELECT CURRENT_TIMESTAMP
FROM DUAL
= 2019-01-31 06:55:07
|
ADD_MONTHS |
Renvoie la date et un nombre entier de mois :
ADD_MONTHS(SYSDATE, 1)
= 31-JAN-19
|
Nécessite un nom de fonction différent | ADDDATE |
La fonction Cloud SQL pour MySQL renvoie un format datetime différent. Pour formater la sortie, utilisez la fonction DATE_FORMAT().
ADDDATE(SYSDATE(), 1)
= 2019-08-01 06:42:49.0
|
EXTRACT (partie de la date) |
Renvoie la valeur d'un champ datetime en fonction d'une expression d'intervalle :
EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019
|
Oui | EXTRACT (partie de la date) |
EXTRACT(YEAR FROM DATE '2019-01-31')
= 2019
|
LAST_DAY |
Renvoie le dernier jour du mois pour une date donnée :
LAST_DAY('01-JAN-2019')
= 31-JAN-19
|
En partie | LAST_DAY |
La fonction Cloud SQL pour MySQL renvoie un format datetime différent du format par défaut pour Oracle. Pour formater la sortie, utilisez la fonction DATE_FORMAT().
LAST_DAY('2019-01-01')
= 2019-01-31
|
MONTH_
BETWEEN
|
Renvoie le nombre de mois entre les dates données date1 et date2 :
MONTHS_BETWEEN(
SYSDATE, SYSDATE-60)
= 1.96
|
En partie |
PERIOD_DIFF
|
La fonction Cloud SQL pour MySQL PERIOD_DIFF renvoie la différence en mois entre deux périodes sous forme de nombre entier (au format YYMM ou YYYYMM) :
PERIOD_DIFF(
'201903', '201901')
= 2
|
TO_CHAR (Datetime) |
Convertit une valeur de type numérique, datetime ou d'horodatage en valeur de type chaîne
TO_CHAR(
SYSDATE,'DD-MM-YYYY HH24:MI:SS')
= 01-01-2019 10:01:01
|
Nécessite un nom de fonction différent | DATE_FORMAT |
La fonction Cloud SQL pour MySQL DATE_FORMAT met en forme une valeur de date en fonction d'une chaîne de format :
DATE_FORMAT(
SYSDATE(),'%d-%m-%Y %H:%i:%s')
01-01-2019 10:01:01
|
Le tableau suivant indique lorsque les fonctions d'encodage et de décodage Oracle et Cloud SQL for MySQL sont équivalentes (même nom et mêmes fonctionnalités) et lorsqu'une conversion est recommandée.
| Fonction Oracle | Mise en œuvre dans Oracle | Équivalent Cloud SQL pour MySQL | Fonction Cloud SQL pour MySQL | Mise en œuvre dans Cloud SQL pour MySQL |
|---|---|---|---|---|
DECODE |
Compare l'expression à chaque valeur de recherche une par une à l'aide de la fonctionnalité d'une instruction IF-THEN-ELSE |
Non | CASE |
Utiliser l'instruction Cloud SQL pour MySQL CASE pour des fonctionnalités similaires |
DUMP |
Renvoie une valeur VARCHAR2 contenant le code du type de données, la longueur en octets et la représentation interne de l'expression. |
Non | N/A | Incompatible |
ORA_HASH |
Calcule une valeur de hachage pour une expression donnée | Non | MD5 or SHA |
Utilisez la fonction MD5 pour les sommes de contrôle 128 bits ou la fonction SHA pour les sommes de contrôle 160 bits. |
Le tableau suivant détaille les fonctions de conversion Oracle et Cloud SQL pour MySQL qui sont équivalentes par nom et fonctionnalité, et celles pour lesquelles une conversion est recommandée.
| Fonction Oracle | Mise en œuvre dans Oracle | Équivalent Cloud SQL pour MySQL | Fonction Cloud SQL pour MySQL | Mise en œuvre dans Cloud SQL pour MySQL |
|---|---|---|---|---|
CAST |
Convertit un type de données intégré ou une valeur de type collection en un autre type de données intégré ou valeur de type collection :
CAST('1' as int) + 1
= 2
|
En partie | CAST |
Ajuster en fonction de la nécessité d'une conversion explicite ou implicite :
CAST('1' AS SIGNED) + 1
= 2
|
CONVERT |
Convertit une chaîne de caractères d'un jeu de caractères en un autre :
CONVERT (
'Ä Ê Í Õ Ø A B C D E ', 'US7ASCII', 'WE8ISO8859P1')
= ?? ?? ?? A B C
|
En partie | CONVERT |
La fonction CONVERT de Cloud SQL pour MySQL nécessite quelques ajustements de la syntaxe et des paramètres :
CONVERT(
'Ä Ê Í A B C ' USING utf8)
= Ä Ê Í A B C
|
TO_CHAR (chaîne/numérique) |
La fonction convertit un nombre ou une date en chaîne :
TO_CHAR(22.73,'$99.9')
= $22.7
|
Non | FORMAT |
La fonction FORMAT de Cloud SQL pour MySQL convertit un nombre en un format tel que #,###,###.##, en arrondissant le nombre à une décimale, puis en renvoyant le résultat sous forme de chaîne :
CONCAT('$',
FORMAT(22.73, 1))
= $22.7
|
TO_DATE |
La fonction TO_DATE d'Oracle convertit une chaîne en date en fonction du format datetimecode :
TO_DATE(
'2019/01/01', 'yyyy-mm-dd')
= 01-JAN-2019
|
Nécessite un nom de fonction différent | STR_TO_DATE |
La fonction STR_TO_DATE de Cloud SQL pour MySQL prend une chaîne et renvoie une date basée sur un format datetime :
STR_TO_DATE(
'2019/01/01', '%Y/%m/%d')
= 2019-01-01
|
TO_NUMBER |
Convertit l'expression en une valeur d'un type de données NUMBER :
TO_NUMBER('01234')
= 1234
. |
Nécessite un nom de fonction différent | CAST |
Utilisez la fonction Cloud SQL pour MySQL CAST pour renvoyer le même résultat que la fonction TO_NUMBER Oracle :
CAST('01234' as SIGNED)
= 1234
|
Le tableau suivant détaille les fonctions conditionnelles SELECT Oracle et Cloud SQL pour MySQL qui sont équivalentes par nom et fonctionnalité, et celles pour lesquelles une conversion est recommandée.
| Fonction Oracle | Mise en œuvre dans Oracle | Équivalent Cloud SQL pour MySQL | Fonction Cloud SQL pour MySQL | Mise en œuvre dans Cloud SQL pour MySQL |
|---|---|---|---|---|
CASE |
L'instruction CASE choisit parmi une séquence de conditions et exécute une instruction correspondante avec la syntaxe suivante :
CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END
|
Oui | CASE |
En plus de la fonction CASE, Cloud SQL pour MySQL est compatible avec l'utilisation de la gestion conditionnelle IF/ELSE dans l'instruction SELECT :
CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END
|
Le tableau suivant détaille les fonctions null Oracle et Cloud SQL pour MySQL qui sont équivalentes par nom et fonctionnalité, et celles pour lesquelles une conversion est recommandée.
| Fonction Oracle | Mise en œuvre dans Oracle | Équivalent Cloud SQL pour MySQL | Fonction Cloud SQL pour MySQL | Mise en œuvre dans Cloud SQL pour MySQL |
|---|---|---|---|---|
COALESCE |
Renvoie la première expression non nulle de la liste d'expressions :
COALESCE(
null, '1', 'a')
= a
|
Oui | COALESCE |
COALESCE(
null, '1', 'a')
= 1
|
NULLIF |
Effectue une comparaison entre expression1 et expression2. Si les valeurs sont égales, la fonction renvoie null.
Si elles ne sont pas égales, la fonction renvoie expression1 :
NULLIF('1', '2')
= a
|
Oui | NULLIF |
NULLIF('1', '2')
= a
|
NVL |
Remplace une valeur null par une chaîne dans les résultats d'une requête :
NVL(null, 'a')
= a
|
Non | IFNULL |
IFNULL(null, 'a')
= a
|
NVL2 |
Détermine la valeur renvoyée par une requête selon qu'une expression est nulle ou non. | Non | CASE |
L'instruction CASE choisit parmi une séquence de conditions et exécute une instruction correspondante :
CASE WHEN condition THEN result
[WHEN ...] [ELSE result]
END
|
Le tableau suivant détaille les fonctions d'environnement Oracle et Cloud SQL pour MySQL qui sont équivalentes par nom et fonctionnalité, et celles pour lesquelles une conversion est recommandée.
| Fonction Oracle | Mise en œuvre dans Oracle | Équivalent Cloud SQL pour MySQL | Fonction Cloud SQL pour MySQL | Mise en œuvre dans Cloud SQL pour MySQL |
|---|---|---|---|---|
SYS_GUID |
Génère et renvoie un identifiant global unique (valeur RAW) composé de 16 octets :
SELECT SYS_GUID()
FROM DUAL
=
8EFA4A31468B4C6DE05011AC0200009E
|
Non | REPLACE et UUID |
Pour contourner ce problème, utilisez les fonctions REPLACE et UUID pour simuler la fonction SYS_GUID :
REPLACE(
UUID(), '-', '')
|
UID |
Renvoie un entier identifiant de manière unique l'utilisateur de la session (l'utilisateur connecté) :
SELECT UID FROM DUAL
= 43
|
Non | N/A | N/A |
USER |
Renvoie le nom d'utilisateur de l'utilisateur connecté à la session en cours :
SELECT USER FROM DUAL
= username
|
Oui | USER + INSTR + SUBSTR |
La fonction USER de Cloud SQL pour MySQL renvoie le nom d'utilisateur et le nom d'hôte (root@IP_ADDRESS) pour la connexion. Pour ne récupérer que le nom d'utilisateur, utilisez les fonctions supplémentaires suivantes :
SELECT
SUBSTR(USER(), 1, INSTR(USER(), '@') -1) FROM DUAL
= root
|
USERENV |
Renvoie des informations sur la session Oracle actuelle, telles que la langue de la session :
SELECT USERENV('LANGUAGE')
FROM DUAL
= ENGLISH_AMERICA.
AL32UTF8
|
Non |
SHOW SESSION
VARIABLES
|
L'instruction SHOW SESSION VARIABLES de Cloud SQL pour MySQL renvoie les paramètres de la session en cours :
SHOW SESSION VARIABLES LIKE '%collation%';
= utf8_general_ci
|
ROWID |
Oracle attribue à chaque ligne d'une table un ROWID unique pour l'identifier. ROWID est l'adresse de la ligne contenant le numéro de l'objet de données, le bloc de données de la ligne, la position de la ligne et le fichier de données. |
En partie | N/A |
ROW_NUMBER() est disponible à partir de MySQL 8.0. Si vous utilisez une version antérieure, émulez la même fonctionnalité en utilisant une variable de session @row_number. |
ROWNUM |
Renvoie un nombre qui représente l'ordre dans lequel une ligne est renvoyée par une table Oracle. | En partie | N/A | ROW_NUMBER() est disponible à partir de MySQL 8.0. Si vous utilisez une version antérieure, émulez la même fonctionnalité en utilisant une variable de session @row_number. |
Le tableau suivant détaille les fonctions d'agrégation (groupe) Oracle et Cloud SQL pour MySQL qui sont équivalentes par nom et fonctionnalité, et celles pour lesquelles une conversion est recommandée.
| Fonction Oracle | Mise en œuvre dans Oracle | Équivalent Cloud SQL pour MySQL | Fonction Cloud SQL pour MySQL | Mise en œuvre dans Cloud SQL pour MySQL |
|---|---|---|---|---|
AVG |
Renvoie la valeur moyenne d'une colonne ou d'une expression. | Oui | AVG |
Équivalent à Oracle |
COUNT
|
Renvoie le nombre de lignes renvoyées par une requête. | Oui | COUNT |
Équivalent à Oracle |
COUNT
(DISTINCT)
|
Renvoie le nombre de valeurs uniques dans la colonne ou l'expression. | Oui |
COUNT
(DISTINCT)
|
Équivalent à Oracle |
MAX |
Renvoie la valeur maximale d'une colonne ou d'une expression. | Oui | Équivalent à Oracle | |
MIN |
Renvoie la valeur minimale d'une colonne ou d'une expression. | Oui | MIN |
Équivalent à Oracle |
SUM |
Renvoie la somme des valeurs d'une colonne ou d'une expression. | Oui | SUM |
Équivalent à Oracle |
LISTAGG |
Trie les données de chaque groupe spécifié dans la clause ORDER BY et concatène les valeurs de la colonne de mesure :
SELECT LISTAGG(
DEPARTMENT_NAME, ', ')
WITHIN GROUP
(ORDER BY DEPARTMENT_NAME) DEPT
FROM DEPARTMENTS;
-- Single line results
= Accounting, Administration, Benefits, Construction
|
Nécessite un nom et une syntaxe de fonction différents |
GROUP_
CONCAT
|
Utilisez la fonction GROUP_CONCAT de Cloud SQL pour MySQL pour renvoyer des résultats équivalents :
SELECT GROUP_CONCAT(
DEPARTMENT_NAME ORDER BY DEPARTMENT_NAME SEPARATOR ', ') DEPT
FROM DEPARTMENTS;
-- Single line results
= Accounting, Administration, Benefits, Construction
|
Le tableau suivant détaille les cas où la fonction FETCH d'Oracle et Cloud SQL pour MySQL est équivalente par nom et par fonctionnalité.
| Fonction Oracle | Mise en œuvre dans Oracle | Équivalent Cloud SQL pour MySQL | Fonction Cloud SQL pour MySQL | Mise en œuvre dans Cloud SQL pour MySQL |
|---|---|---|---|---|
FETCH |
Récupère un nombre spécifié de lignes de l'ensemble de résultats d'une requête multi-lignes :
SELECT * FROM
EMPLOYEES
FETCH FIRST 10 ROWS ONLY;
|
Oui | LIMIT |
Utilisez la clause MySQL LIMIT pour récupérer des lignes à partir d'une requête :
SELECT * FROM
EMPLOYEES
LIMIT 10;
|
Filtrage, opérateurs et sous-requêtes de base
Le filtrage, les fonctions d'opérateur et les sous-requêtes de base sont relativement simples à convertir, avec un effort minimal requis. L'essentiel de cet effort porte sur la conversion des formats de date, car Oracle et Cloud SQL pour MySQL utilisent des formats de date par défaut différents :
- Par défaut, la fonction
SYSDATEd'Oracle renvoie le format01-AUG-19. - Par défaut, la fonction
SYSDATE()de Cloud SQL pour MySQL renvoie le format2019-08-01 12:04:05.
Pour définir les formats de date et d'heure, utilisez les fonctions MySQL DATE_FORMAT ou STR_TO_DATE.
Le tableau suivant détaille les fonctions de filtrage, d'opérateurs et de sous-requêtes de base Oracle et Cloud SQL pour MySQL qui sont équivalentes par nom et fonctionnalité, et celles pour lesquelles une conversion est recommandée.
| Fonction Oracle | Mise en œuvre dans Oracle | Équivalent Cloud SQL pour MySQL | Fonction Cloud SQL pour MySQL |
|---|---|---|---|
EXISTS/
NOT EXISTS
|
Oui |
EXISTS/
NOT EXISTS
|
SELECT * FROM DEPARTMENTS D
WHERE EXISTS (SELECT 1
FROM EMPLOYEES E
WHERE
E.DEPARTMENT_ID =
D.DEPARTMENT_ID);
|
IN/NOT IN |
Oui | 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 |
Oui | LIKE/NOT LIKE |
SELECT * FROM EMPLOYEES
WHERE FIRST_NAME LIKE '_e_n%';
|
BETWEEN/
NOT BETWEEN
|
Oui |
BETWEEN/
NOT BETWEEN
|
SELECT * FROM EMPLOYEES
WHERE EXTRACT(YEAR FROM HIRE_DATE)
NOT BETWEEN 2001 and 2004;
|
AND/OR |
Oui | AND/OR |
SELECT * FROM EMPLOYEES
WHERE DEPARTMENT_ID IN(100, 101)
AND (SALARY >= 1000 OR HIRE_DATE <= '2006-02-05');
|
SubQuery |
Oui | SubQuery |
Cloud SQL pour MySQL accepte les sous-requêtes dans la clause SELECT, dans la clause JOIN, et pour le filtrage dans les clauses 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);
|
| Opérateurs | Oui | Opérateurs | Cloud SQL pour MySQL est compatible avec tous les opérateurs de base :> | >= | < | <= | = | <> | != |
Bonnes pratiques en matière de requêtes Cloud SQL pour MySQL
Pour maintenir des niveaux de performances similaires entre Cloud SQL pour MySQL et Oracle, vous devrez peut-être optimiser vos requêtes. Ces optimisations incluent la modification des structures d'index et l'ajustement du schéma de base de données. Cette section fournit quelques consignes pour vous aider à obtenir des performances de requête similaires sur Cloud SQL pour MySQL.
Créer un index en cluster
Lorsque vous utilisez le moteur de stockage InnoDB, il est recommandé de définir une table avec une clé primaire, car cette clé crée un index en cluster sur la table. En plus d'améliorer les performances des requêtes, cette approche vous permet également de créer des index secondaires supplémentaires. Toutefois, il n'est pas souhaitable de créer trop d'index. Les index redondants n'améliorent pas les performances et peuvent ralentir l'exécution du LMD. Cette bonne pratique conduit à une deuxième bonne pratique qui consiste à surveiller régulièrement les index redondants et, le cas échéant, les supprimer de la base de données.
Utilisez la requête suivante pour identifier les tables sans clé primaire afin de pouvoir créer ces clés le cas échéant :
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';
Utilisez la requête suivante pour rechercher des tables sans index afin de pouvoir créer ces index le cas échéant :
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';
Utilisez la requête suivante pour rechercher des index redondants afin de supprimer les redondances :
mysql> SELECT * FROM sys.schema_redundant_indexes;
Ajuster les paramètres de requête
Pour ajuster les performances des requêtes, vous aurez peut-être besoin d'ajuster les paramètres de session. Cloud SQL pour MySQL dispose d'un ensemble d'options que vous pouvez modifier à cette fin, y compris les options suivantes :
- Paramètres liés à InnoDB
- Paramètres
SORT - Paramètres
JOIN - Paramètres de gestion du cache
Surveiller les requêtes
Les requêtes lentes peuvent empêcher le système de répondre ou générer d'autres goulots d'étranglement. Il est donc important de surveiller régulièrement les requêtes.
Il existe plusieurs façons de diagnostiquer les instructions SQL lentes :
- Utilisez le tableau de bord Cloud SQL pour MySQL pour obtenir des informations en temps réel et historiques sur les requêtes lentes.
- Utilisez Cloud Monitoring pour surveiller le journal des requêtes lentes de Cloud SQL pour MySQL.
Utilisez la vue
statement_analysisde Cloud SQL pour MySQL afin d'afficher les statistiques d'exécution d'une instruction SQL :mysql> SELECT * FROM sys.statement_analysis;
Analyser les requêtes Cloud SQL pour MySQL
L'optimiseur de requêtes de Cloud SQL pour MySQL génère un plan d'exécution pour les instructions SELECT, INSERT, UPDATE et DELETE. Ces plans sont utiles lorsque vous ajustez une requête lente. Les points suivants sont à prendre en compte :
- Les plans d'exécution ne sont pas des objets de base de données qui doivent être migrés, mais plutôt un outil permettant d'analyser les différences de performances entre Oracle et Cloud SQL pour MySQL en exécutant la même instruction sur des ensembles de données identiques.
- Cloud SQL pour MySQL ne prend pas en charge les mêmes syntaxes, fonctionnalités ou sorties de plan d'exécution qu'Oracle.
Voici un exemple de plan illustrant les différences entre un plan d'exécution Oracle et un plan d'exécution Cloud SQL pour 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 |
+----+-------------+-----------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
Optimiser les procédures stockées et les déclencheurs
Contrairement à Oracle, les procédures et fonctions stockées Cloud SQL pour MySQL sont analysées à chaque exécution. L'utilitaire MySQL BENCHMARK() permet de comparer les performances des procédures et des fonctions stockées.
Cet outil prend deux paramètres, à savoir un nombre d'itérations et une expression, et estime la durée d'exécution de l'expression donnée (par exemple, procédure stockée, fonction et instruction SELECT). Le résultat représente le temps d'exécution total approximatif sur toutes les itérations.
L'exemple suivant présente l'utilitaire 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
Si vous remarquez une régression des performances lors de la conversion, utilisez la commande MySQL EXPLAIN pour identifier les facteurs pouvant contribuer à la régression. Une solution courante pour les performances lentes consiste à modifier la structure d'un index de table pour l'adapter à l'optimiseur MySQL. Une autre pratique courante consiste à optimiser un code PL/SQL converti en réduisant la récupération inutile de données ou en utilisant des tables temporaires dans le code MySQL procédural.
Étape suivante
- En savoir plus sur les comptes utilisateur MySQL
- Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.