Convertir et optimiser des requêtes depuis la base de données Oracle vers Cloud SQL pour MySQL

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 SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY
Oui SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY
SELECT pour l'impression en sortie SELECT 1 FROM DUAL Oui SELECT 1
ou
SELECT 1 FROM DUAL
Alias de colonne SELECT COL1 AS C1 Oui SELECT COL1 AS C1
ou
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 :

  • UNION associe les ensembles de résultats de deux instructions SELECT après avoir supprimé les enregistrements en double.
  • UNION ALL associe les ensembles de résultats de deux instructions SELECT sans supprimer les enregistrements en double.
  • INTERSECT renvoie l'intersection de deux instructions SELECT, uniquement si un enregistrement figure dans les ensembles de résultats des deux requêtes.
  • MINUS compare deux instructions SELECT ou 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 TBL1
UNION
SELECT COL1 FROM TBL2
Oui SELECT COL1 FROM TBL1
UNION
SELECT COL1 FROM TBL2
UNION ALL SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2
Oui SELECT COL1 FROM TBL1
UNION ALL
SELECT COL1 FROM TBL2
INTERSECT SELECT COL1 FROM TBL1
INTERSECT
SELECT COL1 FROM TBL2
Non SELECT COL1 FROM TBL1
WHERE COL1 IN
(SELECT COL1 FROM TBL2)
MINUS SELECT COL1 FROM TBL1
MINUS
SELECT 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 SYSDATE() de Cloud SQL pour MySQL doit inclure des parenthèses et renvoie par défaut un format datetime différent de la fonction SYSDATE d'Oracle :

SELECT SYSDATE() FROM DUAL; = 2019-01-31 10:01:01.0

Vous pouvez modifier le format datetime au niveau de la session.

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 MAX É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 SYSDATE d'Oracle renvoie le format 01-AUG-19.
  • Par défaut, la fonction SYSDATE() de Cloud SQL pour MySQL renvoie le format 2019-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_analysis de 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.