Migration d'Oracle vers Amazon RDS for MySQL ou Amazon Aurora MySQL avec AWS Schema Conversion Tool - AWS Schema Conversion Tool
Privilèges pour MySQL en tant que cibleParamètres de conversion Oracle vers MySQLConsidérations concernant la migrationConversion de l'instruction WITH

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Migration d'Oracle vers Amazon RDS for MySQL ou Amazon Aurora MySQL avec AWS Schema Conversion Tool

Pour émuler les fonctions de base de données Oracle dans votre code MySQL converti, utilisez le pack d'extension Oracle to MySQL dans AWS SCT. Pour plus d’informations sur les packs d’extension, consultez Utilisation de packs d'extension avec AWS Schema Conversion Tool.

Privilèges pour MySQL en tant que base de données cible

Les privilèges requis pour MySQL en tant que cible sont les suivants :

  • CRÉER SUR* . *

  • MODIFIER * . *

  • DÉPOSEZ * . *

  • INDEX SUR * . *

  • RÉFÉRENCES SUR* . *

  • SELECT ON *.*

  • CRÉER UNE VUE SUR * . *

  • SHOW VIEW ON *.*

  • DÉCLENCHEUR ACTIVÉ* . *

  • CRÉER UNE ROUTINE SUR* . *

  • MODIFIER LA ROUTINE SUR * . *

  • EXÉCUTER SUR* . *

  • CRÉER DES TABLES TEMPORAIRES SUR* . *

  • AWS_LAMBDA_ACCÈS

  • INSÉRER, METTRE À JOUR SUR AWS_ORACLE _EXT. *

  • INSÉREZ, METTEZ À JOUR, SUPPRIMEZ SUR AWS_ORACLE _EXT_DATA. *

Si vous utilisez une base de données MySQL version 5.7 ou inférieure comme cible, accordez l'autorisation INVOKE LAMBDA *.* au lieu de AWS_LAMBDA _ACCESS. Pour les bases de données MySQL version 8.0 et supérieures, accordez l' AWS_LAMBDA_ACCESS autorisation.

Vous pouvez utiliser l’exemple de code suivant pour créer un utilisateur de base de données et accorder les privilèges.

CREATE USER 'user_name' IDENTIFIED BY 'your_password';
GRANT CREATE ON *.* TO 'user_name';
GRANT ALTER ON *.* TO 'user_name';
GRANT DROP ON *.* TO 'user_name';
GRANT INDEX ON *.* TO 'user_name';
GRANT REFERENCES ON *.* TO 'user_name';
GRANT SELECT ON *.* TO 'user_name';
GRANT CREATE VIEW ON *.* TO 'user_name';
GRANT SHOW VIEW ON *.* TO 'user_name';
GRANT TRIGGER ON *.* TO 'user_name';
GRANT CREATE ROUTINE ON *.* TO 'user_name';
GRANT ALTER ROUTINE ON *.* TO 'user_name';
GRANT EXECUTE ON *.* TO 'user_name';
GRANT CREATE TEMPORARY TABLES ON *.* TO 'user_name';
GRANT AWS_LAMBDA_ACCESS TO 'user_name';
GRANT INSERT, UPDATE ON AWS_ORACLE_EXT.* TO 'user_name';
GRANT INSERT, UPDATE, DELETE ON AWS_ORACLE_EXT_DATA.* TO 'user_name';

Dans l'exemple précédent, remplacez user_name par le nom de votre utilisateur. Remplacez-le ensuite your_password par un mot de passe sécurisé.

Si vous utilisez une base de données MySQL version 5.7 ou inférieure comme cible, utilisez GRANT INVOKE LAMBDA ON *.* TO 'user_name' plutôt queGRANT AWS_LAMBDA_ACCESS TO 'user_name'.

Pour utiliser Amazon RDS for MySQL ou Aurora MySQL en tant que cible, définissez le paramètre lower_case_table_names sur 1. Cette valeur signifie que le serveur MySQL traite les identifiants des noms d’objets tels que les tables, les index, les déclencheurs et les bases de données sans distinction entre majuscules et minuscules. Si vous avez activé la journalisation binaire dans votre instance cible, définissez le paramètre log_bin_trust_function_creators sur 1. Dans ce cas, vous n’avez pas besoin d’utiliser les caractéristiques DETERMINISTIC, READS SQL DATA ni NO SQL pour créer des fonctions stockées. Pour configurer ces paramètres, créez un nouveau groupe de paramètres de base de données ou modifiez un groupe de paramètres de base de données existant.

Paramètres de conversion Oracle vers MySQL

Pour modifier les paramètres de conversion d'Oracle vers MySQL, choisissez Paramètres dans AWS SCT, puis sélectionnez Paramètres de conversion. Dans la liste supérieure, choisissez Oracle, puis Oracle — MySQL. AWS SCT affiche tous les paramètres disponibles pour la conversion d'Oracle vers MySQL.

Les paramètres de conversion d'Oracle vers MySQL AWS SCT incluent des options pour les éléments suivants :

  • Pour limiter le nombre de commentaires contenant des actions dans le code converti.

    Pour Ajouter des commentaires dans le code converti pour les actions de gravité sélectionnée ou supérieure, choisissez la sévérité des actions. AWS SCT ajoute des commentaires dans le code converti pour les actions dont la gravité est sélectionnée ou supérieure.

    Par exemple, pour réduire au maximum le nombre de commentaires dans votre code converti, choisissez Erreurs uniquement. Pour inclure les commentaires pour tous les éléments d’action de votre code converti, choisissez Tous les messages.

  • Pour résoudre ce problème, votre base de données Oracle source peut utiliser la ROWID pseudocolonne, mais MySQL ne prend pas en charge des fonctionnalités similaires. AWS SCT peut émuler la ROWID pseudocolonne dans le code converti. Pour ce faire, choisissez Generate as identity pour Generate row ID ? .

    Si votre code source Oracle n'utilise pas la ROWID pseudocolonne, choisissez Ne pas générer pour Generate row ID ? Dans ce cas, le code converti fonctionne plus rapidement.

  • Pour travailler avec votre code source Oracle lorsqu'il inclut les TO_NUMBER fonctions TO_CHARTO_DATE, et avec des paramètres que MySQL ne prend pas en charge. Par défaut, AWS SCT émule l'utilisation de ces paramètres dans le code converti.

    Lorsque votre code source Oracle inclut uniquement des paramètres pris en charge par PostgreSQL, vous pouvez utiliser TO_CHAR MySQL TO_DATE natif et ses fonctions. TO_NUMBER Dans ce cas, le code converti fonctionne plus rapidement. Pour inclure uniquement ces paramètres, sélectionnez les valeurs suivantes :

    • La fonction TO_CHAR () n'utilise pas de chaînes de formatage spécifiques à Oracle

    • La fonction TO_DATE () n'utilise pas de chaînes de formatage spécifiques à Oracle

    • La fonction TO_NUMBER () n'utilise pas de chaînes de formatage spécifiques à Oracle

  • Pour déterminer si votre base de données et vos applications s'exécutent dans des fuseaux horaires différents. Par défaut, AWS SCT émule les fuseaux horaires dans le code converti. Toutefois, vous n’avez pas besoin de cette émulation lorsque votre base de données et vos applications utilisent le même fuseau horaire. Dans ce cas, sélectionnez Le fuseau horaire du côté client correspond au fuseau horaire du serveur.

Considérations concernant la migration

Lorsque vous convertissez Oracle en RDS for MySQL ou Aurora MySQL, vous pouvez utiliser une GOTO instruction et une étiquette pour modifier l'ordre dans lequel les instructions s'exécutent. Toutes les instructions PL/SQL qui suivent une GOTO instruction sont ignorées et le traitement se poursuit au niveau de l'étiquette. Vous pouvez utiliser GOTO des instructions et des étiquettes n'importe où dans une procédure, un lot ou un bloc d'instructions. Vous pouvez également suivre les instructions GOTO.

MySQL n'utilise pas d'GOTOinstructions. Lors de la AWS SCT conversion du code contenant une GOTO instruction, il convertit l'instruction pour utiliser une LOOP…END LOOP instruction BEGIN…END or.

Vous trouverez des exemples de AWS SCT conversion d'GOTOinstructions dans le tableau suivant.

Instruction Oracle Instruction MySQL 
BEGIN
   ....
   statement1;
   ....
   GOTO label1;
   statement2;
   ....
   label1:
   Statement3;
   ....
END

BEGIN
 label1:
 BEGIN
   ....
   statement1;
   ....
   LEAVE label1;
   statement2;
   ....
 END;
   Statement3;
   ....
END

BEGIN
   ....
   statement1;
   ....
   label1:
   statement2;
   ....
   GOTO label1;
   statement3;
   ....
   statement4;
   ....
END

BEGIN
   ....
   statement1;
   ....
   label1:
   LOOP
    statement2;
    ....
    ITERATE label1;
    LEAVE label1;
   END LOOP; 
    statement3;
    ....
    statement4;
    ....
END

BEGIN
   ....
   statement1;
   ....
   label1:
   statement2;
   ....
   statement3;
   ....
   statement4;
   ....
END

BEGIN
   ....
   statement1;
   ....
   label1:
   BEGIN
    statement2;
    ....    
    statement3;
    ....
    statement4;
    ....    
   END; 
END

Conversion de l'instruction WITH dans Oracle en RDS pour MySQL ou Amazon Aurora MySQL

Vous utilisez la clause WITH (subquery_factoring) dans Oracle pour attribuer un nom (query_name) à un bloc contenant une sous-requête. Vous pouvez ensuite référencer plusieurs endroits de bloc contenant la sous-requête dans la requête en spécifiant query_name. Si un bloc de sous-requête ne contient ni liens ni paramètres (local, procédure, fonction, package), AWS SCT convertit la clause en vue ou en table temporaire.

L'avantage de convertir la clause en table temporaire est que les références répétées à la sous-requête peuvent être plus efficaces. Cette amélioration de l'efficacité s'explique par le fait que les données sont facilement extraites de la table temporaire au lieu d'être requises par chaque référence. Vous pouvez l'émuler en utilisant des vues supplémentaires ou une table temporaire. Le nom de la vue utilise le format <procedure_name>$<subselect_alias>.

Vous trouverez des exemples dans le tableau ci-dessous.

Instruction Oracle Instruction MySQL 
CREATE PROCEDURE 
 TEST_ORA_PG.P_WITH_SELECT_VARIABLE_01
     (p_state IN NUMBER)
AS
  l_dept_id NUMBER := 1; 
BEGIN
FOR cur IN  
           (WITH dept_empl(id, name, surname, 
              lastname, state, dept_id)
              AS
                  (
                    SELECT id, name, surname,  
                     lastname, state, dept_id 
                      FROM test_ora_pg.dept_employees
                     WHERE state = p_state AND 
                       dept_id = l_dept_id)
            SELECT id,state   
              FROM dept_empl
            ORDER BY id)  LOOP
  NULL;
END LOOP;

CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_VARIABLE_01(IN par_P_STATE DOUBLE)
BEGIN
    DECLARE var_l_dept_id DOUBLE DEFAULT 1;
    DECLARE var$id VARCHAR (8000);
    DECLARE var$state VARCHAR (8000);
    DECLARE done INT DEFAULT FALSE;
    DECLARE cur CURSOR FOR SELECT
        ID, STATE
        FROM (SELECT
            ID, NAME, SURNAME, LASTNAME, STATE, DEPT_ID
            FROM TEST_ORA_PG.DEPT_EMPLOYEES
            WHERE STATE = par_p_state AND DEPT_ID = var_l_dept_id) AS dept_empl
        ORDER BY ID;
    DECLARE CONTINUE HANDLER FOR NOT FOUND
        SET done := TRUE;
    OPEN cur;

    read_label:
    LOOP
        FETCH cur INTO var$id, var$state;

        IF done THEN
            LEAVE read_label;
        END IF;

        BEGIN
        END;
    END LOOP;
    CLOSE cur;
END;

CREATE PROCEDURE 
 TEST_ORA_PG.P_WITH_SELECT_REGULAR_MULT_01
AS    
BEGIN

 FOR cur IN  (
               WITH dept_empl AS
                   (
                        SELECT id, name, surname, 
                         lastname, state, dept_id 
                          FROM test_ora_pg.dept_employees
                         WHERE state = 1),
                    dept AS 
                   (SELECT id deptid, parent_id, 
                      name deptname
                      FROM test_ora_pg.department                
                   )
                SELECT dept_empl.*,dept.*          
                 FROM dept_empl, dept
                 WHERE dept_empl.dept_id = dept.deptid
              ) LOOP
              NULL;
            END LOOP;

CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl
 `(id, name, surname, lastname, state, dept_id)
AS
(SELECT id, name, surname, lastname, state, dept_id 
   FROM test_ora_pg.dept_employees
  WHERE state = 1);
  
CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept
 `(deptid, parent_id,deptname)
AS
(SELECT id deptid, parent_id, name deptname
   FROM test_ora_pg.department);  


CREATE PROCEDURE test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()
BEGIN
    DECLARE var$ID DOUBLE;
    DECLARE var$NAME VARCHAR (30);
    DECLARE var$SURNAME VARCHAR (30);
    DECLARE var$LASTNAME VARCHAR (30);
    DECLARE var$STATE DOUBLE;
    DECLARE var$DEPT_ID DOUBLE;
    DECLARE var$deptid DOUBLE;
    DECLARE var$PARENT_ID DOUBLE;
    DECLARE var$deptname VARCHAR (200);
    DECLARE done INT DEFAULT FALSE;
    DECLARE cur CURSOR FOR SELECT
        dept_empl.*, dept.*
        FROM TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl
          ` AS dept_empl,
             TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept
          ` AS dept
        WHERE dept_empl.DEPT_ID = dept.DEPTID;
    DECLARE CONTINUE HANDLER FOR NOT FOUND
        SET done := TRUE;
    OPEN cur;

    read_label:
    LOOP
    FETCH cur INTO var$ID, var$NAME, var$SURNAME, 
     var$LASTNAME, var$STATE, var$DEPT_ID, var$deptid, 
     var$PARENT_ID, var$deptname;

        IF done THEN
            LEAVE read_label;
        END IF;

        BEGIN
        END;
    END LOOP;
    CLOSE cur;
END;

call test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()

CREATE PROCEDURE 
  TEST_ORA_PG.P_WITH_SELECT_VAR_CROSS_02(p_state IN NUMBER)
AS    
   l_dept_id NUMBER := 10;
BEGIN
 FOR cur IN  (
               WITH emp AS              
                    (SELECT id, name, surname, 
                      lastname, state, dept_id 
                       FROM test_ora_pg.dept_employees
                      WHERE dept_id > 10                 
                    ),
                    active_emp AS
                    (
                      SELECT id
                        FROM emp
                       WHERE emp.state = p_state 
                    )
                    
                SELECT *          
                  FROM active_emp                 
              ) LOOP
         NULL;
  END LOOP;
  
END;

CREATE VIEW TEST_ORA_PG.`P_WITH_SELECT_VAR_CROSS_01$emp
    `(id, name, surname, lastname, state, dept_id)
AS
(SELECT
       id, name, surname, lastname, 
       state, dept_id
  FROM TEST_ORA_PG.DEPT_EMPLOYEES
  WHERE DEPT_ID > 10);


CREATE PROCEDURE 
   test_ora_pg.P_WITH_SELECT_VAR_CROSS_02(IN par_P_STATE DOUBLE)
BEGIN
    DECLARE var_l_dept_id DOUBLE DEFAULT 10;
    DECLARE var$ID DOUBLE;
    DECLARE done INT DEFAULT FALSE;
    DECLARE cur CURSOR FOR SELECT *
                             FROM (SELECT
                                      ID
                                     FROM 
                             TEST_ORA_PG.
                              `P_WITH_SELECT_VAR_CROSS_01$emp` AS emp
                                   WHERE emp.STATE = par_p_state) 
                                    AS active_emp;
    DECLARE CONTINUE HANDLER FOR NOT FOUND
        SET done := TRUE;
    OPEN cur;

    read_label:
    LOOP
        FETCH cur INTO var$ID;

        IF done THEN
            LEAVE read_label;
        END IF;

        BEGIN
        END;
    END LOOP;
    CLOSE cur;
END;