AWS Schema Conversion Tool을 사용하여 Oracle에서 Amazon RDS for MySQL 또는 Amazon Aurora MySQL로 마이그레이션 - AWS Schema Conversion Tool
MySQL을 대상으로 사용하기 위한 권한Oracle에서 MySQL로의 변환 설정마이그레이션 고려 사항WITH 문 변환

AWS Schema Conversion Tool을 사용하여 Oracle에서 Amazon RDS for MySQL 또는 Amazon Aurora MySQL로 마이그레이션

변환된 MySQL 코드에서 Oracle 데이터베이스 함수를 에뮬레이션하려면 AWS SCT에서 Oracle-MySQL 확장 팩을 사용합니다. 확장 팩에 대한 자세한 내용은 AWS Schema Conversion Tool과 함께 확장 팩 사용 섹션을 참조하세요.

MySQL을 대상 데이터베이스로 사용하기 위한 권한

MySQL을 대상으로 사용하기 위해 필요한 권한은 다음과 같습니다.

  • CREATE ON *.*

  • ALTER ON *.*

  • DROP ON *.*

  • INDEX ON *.*

  • REFERENCES ON *.*

  • SELECT ON *.*

  • CREATE VIEW ON *.*

  • SHOW VIEW ON *.*

  • TRIGGER ON *.*

  • CREATE ROUTINE ON *.*

  • ALTER ROUTINE ON *.*

  • EXECUTE ON *.*

  • CREATE TEMPORARY TABLES ON *.*

  • AWS_LAMBDA_ACCESS

  • INSERT, UPDATE ON AWS_ORACLE_EXT.*

  • INSERT, UPDATE, DELETE ON AWS_ORACLE_EXT_DATA.*

MySQL 데이터베이스 버전 5.7 이하를 대상으로 사용하는 경우 AWS_LAMBDA_ACCESS 대신 I INVOKE LAMBDA *.* 권한을 부여합니다. MySQL 데이터베이스 버전 8.0 이상의 경우 AWS_LAMBDA_ACCESS 권한을 부여합니다.

다음 코드 예제를 사용하여 데이터베이스 사용자를 생성하고 권한을 부여할 수 있습니다.

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

이전 예제에서 user_name을 사용자 이름으로 바꿉니다. 그런 다음 your_password를 안전한 암호로 바꿉니다.

MySQL 데이터베이스 버전 5.7 이하를 대상으로 사용하는 경우 GRANT AWS_LAMBDA_ACCESS TO 'user_name' 대신 GRANT INVOKE LAMBDA ON *.* TO 'user_name'을 사용합니다.

Amazon RDS for MySQL 또는 Amazon RDS for Aurora MySQL을 대상으로 사용하려면 lower_case_table_names 파라미터를 1로 설정합니다. 이 값은 MySQL 서버가 테이블, 인덱스, 트리거 및 데이터베이스와 같은 객체 이름의 식별자를 대소문자 구분 없이 처리한다는 것을 의미합니다. 대상 인스턴스에서 이진 로깅을 활성화했다면 log_bin_trust_function_creators 파라미터를 1로 설정합니다. 이 경우 저장된 함수를 생성하기 위해 DETERMINISTIC, READS SQL DATA 또는 NO SQL 특성을 사용할 필요가 없습니다. 이들 파라미터를 구성하려면 새 DB 파라미터 그룹을 생성하거나 기존 DB 파라미터 그룹을 수정해야 합니다.

Oracle에서 MySQL로의 변환 설정

Oracle에서 MySQL로의 변환 설정을 편집하려면 AWS SCT에서 설정을 선택한 다음 변환 설정을 선택합니다. 상단 목록에서 Oracle을 선택한 다음 Oracle – MySQL을 선택합니다. AWS SCT는 Oracle에서 MySQL로의 변환에 사용할 수 있는 모든 설정을 표시합니다.

AWS SCT의 경우, Oracle에서 MySQL로의 변환 설정에는 다음에 대한 옵션이 포함됩니다.

  • 변환된 코드에서 작업 항목이 포함된 설명의 수를 제한합니다.

    Add comments in the converted code for the action items of selected severity and higher에서 작업 항목의 심각도를 선택합니다. AWS SCT가 선택된 심각도 이상의 작업 항목에 대한 변환된 코드에 설명을 추가합니다.

    예를 들어, 변환된 코드의 설명 수를 최소화하려면 오류만을 선택합니다. 변환된 코드의 모든 작업 항목에 대한 설명을 포함하려면 모든 메시지를 선택합니다.

  • 소스 Oracle 데이터베이스가 ROWID 의사 열을 사용할 수 있지만 MySQL이 유사한 기능을 지원하지 않는 문제를 해결합니다. AWS SCT는 ROWID 의사 열을 변환된 코드로 에뮬레이션할 수 있습니다. 이렇게 하려면 행 ID 생성?에서 Generate as identity를 선택합니다.

    소스 Oracle 코드에서 ROWID 의사 열을 사용하지 않는 경우 행 ID 생성?에서 Don't generate를 선택합니다. 이 경우, 변환된 코드는 더 빠르게 작동합니다.

  • MySQL에서 지원하지 않는 파라미터가 있는 TO_CHAR, TO_DATE 및 TO_NUMBER 함수를 포함하는 경우 소스 Oracle 코드를 사용하여 작업합니다. 기본적으로 AWS SCT는 이러한 파라미터의 사용을 변환된 코드로 에뮬레이션합니다.

    소스 Oracle 코드에 PostgreSQL이 지원하는 파라미터만 포함되어 있는 경우 기본 MySQL TO_CHAR, TO_DATE 및 TO_NUMBER 함수를 사용할 수 있습니다. 이 경우, 변환된 코드는 더 빠르게 작동합니다. 이러한 파라미터만 포함하려면 다음 값을 선택합니다.

    • Function TO_CHAR() does not use Oracle specific formatting strings

    • Function TO_DATE() does not use Oracle specific formatting strings

    • Function TO_NUMBER() does not use Oracle specific formatting strings

  • 데이터베이스와 애플리케이션이 서로 다른 시간대에서 실행되는지 여부를 확인합니다. 기본적으로 AWS SCT는 변환된 코드로 시간대를 에뮬레이션합니다. 하지만 데이터베이스와 애플리케이션이 동일한 시간대를 사용하는 경우에는 이 에뮬레이션이 필요하지 않습니다. 이 경우 Time zone on the client side matches the time zone on server를 선택합니다.

마이그레이션 고려 사항

Oracle을 RDS for MySQL 또는 Aurora MySQL로 변환할 때 명령문이 실행되는 순서를 변경하려면 GOTO 문과 레이블을 사용할 수 있습니다. GOTO 문 뒤에 오는 PL/SQL 문은 건너뛰며 프로세스는 레이블에서 계속됩니다. GOTO 문과 레이블은 프로시저, 배치(batch), 명령문 블록 내 어디든 사용할 수 있습니다. 또한 다음 GOTO 문에도 사용할 수 있습니다.

MySQL은 GOTO 문을 사용하지 않습니다. AWS SCT는 GOTO 문을 포함하는 코드를 변환할 때 BEGIN…END 문 또는 LOOP…END LOOP 문을 사용하도록 명령문을 변환합니다.

다음 테이블에는 AWS SCT가 GOTO 문을 어떻게 변환하는지에 대한 예가 나와 있습니다.

Oracle 문 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

Oracle의 WITH 문을 RDS for MySQL 또는 Amazon Aurora MySQL로 변환

Oracle의 WITH 절(subquery_factoring)을 사용하여 서브쿼리 블록에 이름(쿼리 이름)을 할당할 수 있습니다. 그런 다음 쿼리 이름을 지정하여 이 서브쿼리 블록을 쿼리의 여러 위치에서 참조할 수 있습니다. 서브쿼리 블록에는 링크나 파라미터(local, procedure, function, package)가 없으므로 AWS SCT는 이 절을 보기 또는 임시 테이블로 변환합니다.

이 절을 임시 테이블로 변환하면 서브쿼리에 대한 반복된 참조를 보다 효율화할 수 있습니다. 그 이유는 데이터를 각 참조에서 요구하지 않고 임시 테이블에서 데이터를 쉽게 검색할 수 있기 때문입니다. 보기 또는 임시 테이블을 추가로 사용하여 이를 에뮬레이션할 수 있습니다. 뷰 이름은 <procedure_name>$<subselect_alias> 형식을 사용합니다.

다음 테이블에서 예제를 찾을 수 있습니다.

Oracle 문 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;