Migration von Oracle zu Amazon RDS for My SQL oder Amazon Aurora My SQL mit dem AWS Schema Conversion Tool - AWS Schema Conversion Tool
Rechte für My SQL als ZielEinstellungen für die SQL Konvertierung von Oracle zu MyÜberlegungen zur MigrationDie WITH Abrechnung wird konvertiert

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Migration von Oracle zu Amazon RDS for My SQL oder Amazon Aurora My SQL mit dem AWS Schema Conversion Tool

Um Oracle-Datenbankfunktionen in Ihrem konvertierten SQL My-Code zu emulieren, verwenden Sie das Erweiterungspaket Oracle to My SQL in. AWS SCT Weitere Informationen zu Erweiterungspaketen finden Sie unter Verwenden von Erweiterungspaketen mit AWS Schema Conversion Tool.

Berechtigungen für My SQL als Zieldatenbank

Die für My SQL als Ziel erforderlichen Rechte lauten wie folgt:

  • CREATEAM * . *

  • ALTERAM * . *

  • DROPAM * . *

  • INDEXAM * . *

  • REFERENCESAM * . *

  • SELECTAM * . *

  • CREATEVIEWAM * . *

  • SHOWVIEWAM * . *

  • TRIGGERAM * . *

  • CREATEROUTINEAM * . *

  • ALTERROUTINEAM * . *

  • EXECUTEAM * . *

  • CREATETEMPORARYTABLESAM * . *

  • AWS_LAMBDA_ACCESS

  • INSERT, UPDATE AUF AWS _ ORACLE _EXT. *

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

Wenn Sie My SQL Database-Version 5.7 oder niedriger als Ziel verwenden, gewähren Sie statt AWS _ LAMBDA _ ACCESS die Berechtigung INVOKE LAMBDA *.*. Erteilen Sie für Meine SQL Datenbanken, Version 8.0 und höher, die AWS _ LAMBDA _ ACCESS -Berechtigung.

Sie können das folgende Codebeispiel verwenden, um einen Datenbankbenutzer zu erstellen und die Berechtigungen zu gewähren.

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';

Ersetzen Sie im vorherigen Beispiel user_name durch den Namen Ihres Benutzers. Dann ersetze your_password mit einem sicheren Passwort.

Wenn Sie My SQL Database-Version 5.7 oder niedriger als Ziel verwenden, verwenden Sie GRANT INVOKE LAMBDA ON *.* TO 'user_name' anstelle vonGRANT AWS_LAMBDA_ACCESS TO 'user_name'.

Um Amazon RDS for My SQL oder Aurora My SQL als Ziel zu verwenden, setzen Sie den lower_case_table_names Parameter auf1. Dieser Wert bedeutet, dass der SQL My-Server Bezeichner von Objektnamen wie Tabellen, Indizes, Triggern und Datenbanken ohne Berücksichtigung der Groß- und Kleinschreibung behandelt. Wenn Sie die binäre Protokollierung in Ihrer Ziel-Instance aktiviert haben, setzen Sie den Parameter log_bin_trust_function_creators auf 1. In diesem Fall müssen Sie die Eigenschaften DETERMINISTIC, READS SQL DATA oder NO SQL nicht verwenden, um gespeicherte Funktionen zu erstellen. Erstellen Sie zum Konfigurieren dieser Parameter eine neue DB-Parametergruppe oder ändern Sie eine vorhandene DB-Parametergruppe.

Einstellungen für die Konvertierung von Oracle zu My SQL

Um die SQL Konvertierungseinstellungen von Oracle to My zu bearbeiten, wählen Sie Einstellungen in AWS SCT und dann Konvertierungseinstellungen. Wählen Sie in der oberen Liste Oracle und dann Oracle — My ausSQL. AWS SCT zeigt alle verfügbaren Einstellungen für die SQL Konvertierung von Oracle in My an.

Die SQL Konvertierungseinstellungen von Oracle in My AWS SCT enthalten Optionen für Folgendes:

  • Um die Anzahl der Kommentare mit Aktionselementen im konvertierten Code zu begrenzen.

    Wählen Sie für Hinzufügen von Kommentaren zum konvertierten Code für Aktionselemente mit ausgewähltem Schweregrad und höherem Schweregrad den Schweregrad der Aktionspunkte aus. AWS SCT fügt dem konvertierten Code Kommentare für Aktionspunkte mit dem ausgewählten Schweregrad und höher hinzu.

    Beispiel: Um die Anzahl der Kommentare im konvertierten Code zu minimieren, wählen Sie Nur Fehler aus. Um Kommentare zu allen Aktionselementen in den konvertierten Code aufzunehmen, wählen Sie Alle Nachrichten aus.

  • Um dem entgegenzuwirken, kann Ihre Oracle-Quelldatenbank die ROWID Pseudospalte verwenden, aber My unterstützt SQL keine ähnliche Funktionalität. AWS SCT kann die ROWID Pseudospalte im konvertierten Code emulieren. Wählen Sie dazu unter Zeilen-ID generieren? die Option Als Identität generieren aus. .

    Wenn Ihr Oracle-Quellcode die ROWID Pseudospalte nicht verwendet, wählen Sie Don't generate für Generate row ID? In diesem Fall arbeitet der konvertierte Code schneller.

  • Um mit Ihrem Oracle-Quellcode zu arbeiten, wenn er die TO_NUMBER Funktionen TO_CHARTO_DATE, und mit Parametern enthält, die My SQL nicht unterstützt. AWS SCT Emuliert standardmäßig die Verwendung dieser Parameter im konvertierten Code.

    Wenn Ihr Oracle-Quellcode nur Parameter enthält, die Postgre SQL unterstützt, können Sie die systemeigenen Funktionen My SQL TO_CHARTO_DATE, und TO_NUMBER verwenden. In diesem Fall arbeitet der konvertierte Code schneller. Um nur diese Parameter einzubeziehen, wählen Sie die folgenden Werte aus:

    • Die Funktion TO_ CHAR () verwendet keine Oracle-spezifischen Formatierungszeichenfolgen

    • Die Funktion TO_ DATE () verwendet keine Oracle-spezifischen Formatierungszeichenfolgen

    • Die Funktion TO_ NUMBER () verwendet keine Oracle-spezifischen Formatierungszeichenfolgen

  • Um festzustellen, ob Ihre Datenbank und Anwendungen in unterschiedlichen Zeitzonen ausgeführt werden. AWS SCT Emuliert standardmäßig Zeitzonen im konvertierten Code. Sie benötigen diese Emulation jedoch nicht, wenn Ihre Datenbank und Anwendungen dieselbe Zeitzone verwenden. In diesem Fall entspricht die Option Zeitzone auf der Clientseite der Zeitzone auf dem Server.

Überlegungen zur Migration

Wenn Sie Oracle in RDS for My SQL oder Aurora My konvertierenSQL, können Sie eine GOTO Anweisung und ein Label verwenden, um die Reihenfolge zu ändern, in der Anweisungen ausgeführt werden. Alle SQL PL/-Anweisungen, die auf eine GOTO Anweisung folgen, werden übersprungen, und die Verarbeitung wird an der Bezeichnung fortgesetzt. Sie können GOTO Anweisungen und Labels an einer beliebigen Stelle innerhalb einer Prozedur, eines Batches oder eines Anweisungsblocks verwenden. Sie können auch nächste GOTO Anweisungen verwenden.

Meine verwendet SQL keine GOTO Aussagen. Wenn Code AWS SCT konvertiert wird, der eine GOTO Anweisung enthält, wird die Anweisung so konvertiert, dass sie eine BEGIN…END LOOP…END LOOP OR-Anweisung verwendet.

In der folgenden Tabelle finden Sie Beispiele dafür, wie GOTO Anweisungen AWS SCT konvertiert werden.

Oracle-Anweisung Meine SQL Aussage 
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

Umwandlung des WITH Kontoauszugs in Oracle in RDS for My SQL oder Amazon Aurora My SQL

Sie verwenden die WITH Klausel (subquery_factoring) in Oracle, um einem Unterabfrageblock einen Namen (query_name) zuzuweisen. Sie können dann an mehreren Stellen in der Abfrage auf den Unterabfragenblock Bezug nehmen. Wenn ein Unterabfrageblock keine Links oder Parameter (local, procedure, function, package) enthält, AWS SCT konvertiert er die Klausel in eine Ansicht oder eine temporäre Tabelle.

Der Vorteil der Umwandlung der Klausel in eine temporäre Tabelle besteht darin, dass wiederholte Verweise auf die Unterabfrage effizienter sein können. Die größere Effizienz liegt darin, dass die Daten leicht aus der temporären Tabelle abgerufen werden können, anstatt von jeder Referenz benötigt zu werden. Sie können dies emulieren, indem Sie zusätzliche Ansichten oder eine temporäre Tabelle verwenden. Für den Ansichtsnamen wird das Format <procedure_name>$<subselect_alias> verwendet.

Beispiele finden Sie in der folgenden Tabelle.

Oracle-Anweisung Mein SQL Statement 
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;