Migration d'Oracle vers Amazon RDS for My SQL ou Amazon Aurora My à l'SQLaide du AWS Schema Conversion Tool - AWS Schema Conversion Tool
Privilèges réservés à My SQL as a targetParamètres de SQL conversion d'Oracle vers MyConsidérations concernant la migrationConversion de la WITH déclaration

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 My SQL ou Amazon Aurora My à l'SQLaide du AWS Schema Conversion Tool

Pour émuler les fonctions de base de données Oracle dans votre SQL code My code converti, utilisez le pack d'SQLextension Oracle to My 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 My SQL en tant que base de données cible

Les privilèges requis pour My SQL as a target sont les suivants :

  • CREATESUR * . *

  • ALTERSUR * . *

  • DROPSUR * . *

  • INDEXSUR * . *

  • REFERENCESSUR * . *

  • SELECTSUR * . *

  • CREATEVIEWSUR * . *

  • SHOWVIEWSUR * . *

  • TRIGGERSUR * . *

  • CREATEROUTINESUR * . *

  • ALTERROUTINESUR * . *

  • EXECUTESUR * . *

  • CREATETEMPORARYTABLESSUR * . *

  • AWS_LAMBDA_ACCESS

  • INSERT, UPDATE ON AWS _ ORACLE _EXT. *

  • INSERTUPDATE, DELETE ON AWS _ ORACLE _ EXT _DATA. *

Si vous utilisez la version 5.7 ou inférieure de Ma SQL base de données comme cible, accordez l'INVOKELAMBDAautorisation*.* au lieu de AWS _ LAMBDA _ACCESS. Pour les versions 8.0 et supérieures de Mes SQL bases de données, accordez l'ACCESSautorisation AWS LAMBDA _ _.

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 avec le nom de votre utilisateur. Ensuite, remplacez your_password avec un mot de passe sécurisé.

Si vous utilisez une version 5.7 ou inférieure SQL de Ma base de données comme cible, utilisez-la à la GRANT INVOKE LAMBDA ON *.* TO 'user_name' place deGRANT AWS_LAMBDA_ACCESS TO 'user_name'.

Pour utiliser Amazon RDS for My SQL ou Aurora My SQL comme cible, définissez le lower_case_table_names paramètre sur1. Cette valeur signifie que le SQL serveur My gère les identifiants des noms d'objets tels que les tables, les index, les déclencheurs et les bases de données sans distinction majuscules/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 SQL conversion d'Oracle vers My

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

Les paramètres de SQL conversion d'Oracle vers My 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 sévérité 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 remédier à ce problème, votre base de données Oracle source peut utiliser la ROWID pseudocolonne, mais My SQL 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 Générer l'ID de ligne ? 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 My SQL 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 SQL en charge par Postgre, vous pouvez utiliser les TO_NUMBER fonctions natives My SQL TO_CHARTO_DATE, et. 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 My SQL ou Aurora MySQL, pour modifier l'ordre dans lequel les instructions sont exécutées, vous pouvez utiliser une GOTO instruction et une étiquette. Toutes les SQL instructions PL/ qui suivent une GOTO instruction sont ignorées et le traitement se poursuit sur 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 effectuer GOTO les prochaines déclarations.

Je SQL n'utilise pas de GOTO déclarations. 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 Ma SQL déclaration 
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 du WITH relevé dans Oracle en RDS for My SQL ou Amazon Aurora My SQL

Vous utilisez la WITH clause (subquery_factoring) dans Oracle pour attribuer un nom (query_name) à un bloc de 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 pas de liens ou de 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 Ma SQL déclaration 
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;