Migrando da Oracle para o Amazon RDS for My SQL ou o Amazon Aurora SQL My com o AWS Schema Conversion Tool - AWS Schema Conversion Tool
Privilégios para My SQL como alvoConfigurações de SQL conversão de Oracle para MyConsiderações sobre a migraçãoConvertendo a declaração WITH

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Migrando da Oracle para o Amazon RDS for My SQL ou o Amazon Aurora SQL My com o AWS Schema Conversion Tool

Para emular as funções do banco de dados Oracle em seu My SQL code convertido, use o pacote de SQL extensão Oracle to My em AWS SCT. Para obter mais informações sobre pacotes de extensão, consulte Usando pacotes de extensão com AWS Schema Conversion Tool.

Privilégios do My SQL como banco de dados de destino

Os privilégios necessários para My SQL como alvo são os seguintes:

  • CREATEEM * . *

  • ALTEREM * . *

  • DROPEM * . *

  • INDEXEM * . *

  • REFERENCESEM * . *

  • SELECTEM * . *

  • CREATEVIEWEM * . *

  • SHOWVIEWEM * . *

  • TRIGGEREM * . *

  • CREATEROUTINEEM * . *

  • ALTERROUTINEEM * . *

  • EXECUTEEM * . *

  • CREATETEMPORARYTABLESEM * . *

  • AWS_LAMBDA_ACCESS

  • INSERT, UPDATE EM AWS _ ORACLE _EXT. *

  • INSERT,UPDATE, DELETE EM AWS _ ORACLE _ EXT _DATA. *

Se você usar a versão 5.7 ou inferior do Meu SQL banco de dados como destino, conceda a permissão INVOKE LAMBDA *.* em vez de AWS _ _. LAMBDA ACCESS Para Meus SQL bancos de dados versão 8.0 e superior, conceda a ACCESS permissão AWS _ LAMBDA _.

É possível utilizar o exemplo de código a seguir para criar um usuário do banco de dados e conceder os privilégios.

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

No exemplo anterior, substitua user_name com o nome do seu usuário. Em seguida, substitua your_password com uma senha segura.

Se você usar o Meu SQL banco de dados versão 5.7 ou inferior como destino, use GRANT INVOKE LAMBDA ON *.* TO 'user_name' em vez deGRANT AWS_LAMBDA_ACCESS TO 'user_name'.

Para usar o Amazon RDS for My SQL ou o Aurora My SQL como destino, defina o lower_case_table_names parâmetro como. 1 Esse valor significa que o Meu SQL servidor manipula identificadores de nomes de objetos, como tabelas, índices, acionadores e bancos de dados, sem distinção entre maiúsculas e minúsculas. Se você ativou o registro binário em sua instância de destino, defina o parâmetro log_bin_trust_function_creators como 1. Nesse caso, você não precisa usar as características DETERMINISTIC, READS SQL DATA ou NO SQL para criar funções armazenadas. Para configurar esses parâmetros, crie um novo grupo de parâmetros de banco de dados ou modifique um grupo de parâmetros de banco de dados existente.

Configurações de SQL conversão de Oracle para My

Para editar as configurações de SQL conversão do Oracle para Minhas, escolha Configurações em e AWS SCT, em seguida, escolha Configurações de conversão. Na lista superior, escolha Oracle e, em seguida, escolha Oracle — My SQL. AWS SCT exibe todas as configurações disponíveis para a SQL conversão Oracle to My.

As configurações SQL de conversão de Oracle para My AWS SCT incluem opções para o seguinte:

  • Para limitar o número de comentários com itens de ação no código convertido.

    Em Adicionar comentários no código convertido para os itens de ação de severidade selecionada e superior, escolha a severidade dos itens de ação. AWS SCT adiciona comentários no código convertido para itens de ação da severidade selecionada e superior.

    Por exemplo, para minimizar o número de comentários em seu código convertido, escolha Somente erros. Para incluir comentários para todos os itens de ação em seu código convertido, escolha Todas as mensagens.

  • Para resolver isso, seu banco de dados Oracle de origem pode usar a ROWID pseudocoluna, mas My SQL não oferece suporte a funcionalidades semelhantes. AWS SCT pode emular a ROWID pseudocoluna no código convertido. Para fazer isso, escolha Gerar como identidade em Gerar ID de linha?.

    Se o código do Oracle de origem não utilizar a pseudocoluna ROWID, escolha Não gerar em Gerar ID de linha? Nesse caso, o código convertido funciona mais rápido.

  • Para trabalhar com seu código-fonte Oracle quando ele inclui as TO_NUMBER funções TO_CHARTO_DATE, e com parâmetros que o My SQL não suporta. Por padrão, a AWS SCT emula a utilização desses parâmetros no código convertido.

    Quando seu código-fonte Oracle inclui somente parâmetros SQL compatíveis com o Postgre, você pode usar TO_NUMBER as funções nativas My SQL TO_CHARTO_DATE, e. Nesse caso, o código convertido funciona mais rápido. Para incluir somente esses parâmetros, selecione os seguintes valores:

    • A função TO_ CHAR () não usa strings de formatação específicas do Oracle

    • A função TO_ DATE () não usa strings de formatação específicas do Oracle

    • A função TO_ NUMBER () não usa strings de formatação específicas do Oracle

  • Para saber se o banco de dados e as aplicações são executados em fusos horários diferentes. Por padrão, AWS SCT emula os fusos horários no código convertido. No entanto, essa emulação não é necessária quando o banco de dados e as aplicações utilizam o mesmo fuso horário. Nesse caso, selecione O fuso horário no lado do cliente corresponde ao fuso horário no servidor.

Considerações sobre a migração

Ao converter RDS Oracle em for My SQL ou Aurora MySQL, para alterar a ordem em que as instruções são executadas, você pode usar uma GOTO instrução e um rótulo. Todas SQL as declarações PL/que seguem uma GOTO declaração são ignoradas e o processamento continua no rótulo. As instruções GOTO e os rótulos podem ser usados em qualquer lugar em um procedimento, lote ou bloco de instruções. Você também pode fazer GOTO as próximas declarações.

O meu SQL não usa GOTO declarações. Quando AWS SCT converte o código que contém uma GOTO instrução, ele converte a instrução para usar uma instrução BEGIN…END ouLOOP…END LOOP.

Você pode encontrar exemplos de como AWS SCT converte GOTO declarações na tabela a seguir.

Instrução do Oracle Minha SQL declaração 
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

Convertendo a WITH declaração no Oracle RDS para for My SQL ou Amazon Aurora My SQL

Você usa a WITH cláusula (subquery_factoring) no Oracle para atribuir um nome (query_name) a um bloco de subconsulta. Em seguida, você poderá fazer referência ao bloco de subconsulta em vários lugares na consulta especificando query_name. Se um bloco de subconsulta não contiver links ou parâmetros (local, procedimento, função, pacote), AWS SCT converterá a cláusula em uma exibição ou tabela temporária.

A vantagem de converter a cláusula em uma tabela temporária é que referências repetidas à subconsulta podem ser mais eficientes. A maior eficiência ocorre porque os dados são facilmente recuperados da tabela temporária em vez de serem solicitados por cada referência. Isso pode ser emulado com visualizações adicionais ou uma tabela temporária. O nome da visualização usa o formato <procedure_name>$<subselect_alias>.

Você pode encontrar exemplos na tabela a seguir.

Instrução do Oracle Minha SQL declaração 
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;