Migrazione da Oracle ad Amazon RDS for My SQL o Amazon Aurora SQL My con AWS Schema Conversion Tool - AWS Schema Conversion Tool
Privilegi per My SQL come obiettivoImpostazioni di SQL conversione da Oracle a MyConsiderazioni sulla migrazioneConversione della dichiarazione WITH

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Migrazione da Oracle ad Amazon RDS for My SQL o Amazon Aurora SQL My con AWS Schema Conversion Tool

Per emulare le funzioni del database Oracle nel SQL codice My convertito, usa il pacchetto di estensione Oracle to My in. SQL AWS SCT Per ulteriori informazioni sui pacchetti di estensione, consulta Utilizzo dei pacchetti di estensione con AWS Schema Conversion Tool.

Privilegi per My SQL come database di destinazione

I privilegi richiesti per My SQL as a target sono i seguenti:

  • CREATESU* . *

  • ALTERSU * . *

  • DROPSU * . *

  • INDEXSU * . *

  • REFERENCESSU * . *

  • SELECTSU * . *

  • CREATEVIEWSU * . *

  • SHOWVIEWSU * . *

  • TRIGGERSU * . *

  • CREATEROUTINESU * . *

  • ALTERROUTINESU * . *

  • EXECUTESU * . *

  • CREATETEMPORARYTABLESSU * . *

  • AWS_LAMBDA_ACCESS

  • INSERT, UPDATE SU AWS _ ORACLE _EXT. *

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

Se utilizzi una versione 5.7 o precedente di My SQL database come destinazione, concedi l'INVOKELAMBDAautorizzazione*.* anziché AWS _ _. LAMBDA ACCESS Per la versione 8.0 e successive di My SQL databases, concedi l'AWSautorizzazione _ _. LAMBDA ACCESS

È possibile utilizzare il seguente esempio di codice per creare un utente del database e assegnare i privilegi.

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

Nell'esempio precedente, sostituisci user_name con il nome del tuo utente. Quindi, sostituisci your_password con una password sicura.

Se utilizzi una versione 5.7 o precedente di My SQL database come destinazione, usa GRANT INVOKE LAMBDA ON *.* TO 'user_name' invece diGRANT AWS_LAMBDA_ACCESS TO 'user_name'.

Per utilizzare Amazon RDS for My SQL o Aurora My SQL come destinazione, imposta il lower_case_table_names parametro su. 1 Questo valore indica che il SQL server My gestisce gli identificatori di nomi di oggetti come tabelle, indici, trigger e database senza distinzione tra maiuscole e minuscole. Se hai attivato la registrazione binaria nell'istanza di destinazione, imposta il parametro log_bin_trust_function_creators su 1. In questo caso, non è necessario utilizzare le caratteristiche DETERMINISTIC, READS SQL DATA o NO SQL per creare funzioni archiviate. Per configurare questi parametri, crea un nuovo gruppo di parametri di database o modifica un gruppo di parametri di database esistente.

Impostazioni di conversione da Oracle a My SQL

Per modificare le impostazioni di SQL conversione da Oracle a Le mie impostazioni AWS SCT, scegli Impostazioni in, quindi scegli Impostazioni di conversione. Dall'elenco superiore, scegli Oracle, quindi scegli Oracle — My SQL. AWS SCT visualizza tutte le impostazioni disponibili per la SQL conversione da Oracle a My.

Le impostazioni di SQL conversione da Oracle to My AWS SCT includono le seguenti opzioni:

  • Per limitare il numero di commenti con azioni nel codice convertito.

    Per Aggiungi commenti nel codice convertito per le azioni di gravità selezionata o superiore, scegli la gravità delle azioni. AWS SCT aggiunge commenti nel codice convertito per le azioni con la gravità selezionata o superiore.

    Ad esempio, per ridurre al minimo il numero di commenti nel codice convertito, scegli Solo errori. Per includere commenti per tutti gli elementi d'azione nel codice convertito, scegli Tutti i messaggi.

  • Per risolvere il problema, il database Oracle di origine può utilizzare la ROWID pseudocolonna, ma My SQL non supporta funzionalità simili. AWS SCT può emulare la ROWID pseudocolonna nel codice convertito. Per fare ciò, scegli Genera come identità per Genera ID di riga? .

    Se il codice sorgente Oracle non utilizza la ROWID pseudocolonna, scegli Non generare per generare l'ID di riga? In questo caso, il codice convertito funziona più velocemente.

  • Per utilizzare il codice sorgente Oracle quando include TO_CHARTO_DATE, e TO_NUMBER funzioni con parametri SQL non supportati da My. Per impostazione predefinita, AWS SCT emula l'utilizzo di questi parametri nel codice convertito.

    Quando il codice sorgente Oracle include solo parametri SQL supportati da Postgre, è possibile utilizzare le funzioni native My SQL TO_CHAR e. TO_DATE TO_NUMBER In questo caso, il codice convertito funziona più velocemente. Per includere solo questi parametri, seleziona i seguenti valori:

    • La funzione TO_ CHAR () non utilizza stringhe di formattazione specifiche di Oracle

    • La funzione TO_ DATE () non utilizza stringhe di formattazione specifiche di Oracle

    • La funzione TO_ NUMBER () non utilizza stringhe di formattazione specifiche di Oracle

  • Per stabilire se il database e le applicazioni vengono eseguiti in fusi orari diversi. Per impostazione predefinita, AWS SCT emula i fusi orari nel codice convertito. Tuttavia, non è necessaria questa emulazione quando il database e le applicazioni utilizzano lo stesso fuso orario. In questo caso, la selezione Fuso orario sul lato client corrisponde al fuso orario sul server.

Considerazioni sulla migrazione

Quando converti Oracle in RDS for My SQL o Aurora MySQL, per modificare l'ordine di esecuzione delle istruzioni, puoi utilizzare un'GOTOistruzione e un'etichetta. Tutte SQL le istruzioni PL/ che seguono un'GOTOistruzione vengono ignorate e l'elaborazione continua dall'etichetta. È possibile utilizzare GOTO istruzioni ed etichette ovunque all'interno di una procedura, di un batch o di un blocco di istruzioni. È inoltre possibile eseguire GOTO le istruzioni successive.

Il mio SQL non usa GOTO affermazioni. Quando AWS SCT converte il codice che contiene un'GOTOistruzione, converte l'istruzione per utilizzare un'istruzione BEGIN…END orLOOP…END LOOP.

È possibile trovare esempi di come AWS SCT converte GOTO le istruzioni nella tabella seguente.

Istruzione Oracle La mia dichiarazione SQL 
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

Conversione dell'WITHistruzione in Oracle in RDS for My SQL o Amazon Aurora My SQL

Si utilizza la WITH clausola (subquery_factoring) in Oracle per assegnare un nome (query_name) a un blocco di subquery. È quindi possibile fare riferimento al blocco di sottoquery in più posizioni nella query specificando il query_name. Se un blocco di subquery non contiene collegamenti o parametri (locali, procedure, funzioni, pacchetti), converte la clausola in una vista o in una tabella temporanea. AWS SCT

Il vantaggio di convertire la clausola in una tabella temporanea è che i riferimenti ripetuti alla sottoquery potrebbero essere più efficienti. La maggiore efficienza è dovuta al fatto che i dati vengono facilmente recuperati dalla tabella temporanea piuttosto che essere richiesti da ogni riferimento. È possibile emularlo utilizzando viste aggiuntive o una tabella temporanea. Il nome della visualizzazione utilizza il formato <procedure_name>$<subselect_alias>.

È possibile trovare esempi nella tabella seguente.

Istruzione Oracle La mia SQL dichiarazione 
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;