

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# 작업 설정을 지정하기 위한 테이블 매핑 사용
<a name="CHAP_Tasks.CustomizingTasks.TableMapping"></a>

테이블 매핑에서는 여러 유형의 규칙을 사용하여 데이터 소스, 소스 스키마, 데이터, 작업 중 발생하는 모든 변환을 지정합니다. 테이블 매핑을 사용하여 마이그레이션할 데이터베이스의 개별 테이블과 마이그레이션에 사용할 스키마를 지정할 수 있습니다.

테이블 매핑 작업 시 필터를 사용하여 테이블 열에서 복제할 데이터를 지정할 수 있습니다. 또한 변환을 사용하여 선택한 스키마, 테이블 또는 뷰를 대상 데이터베이스에 기록하기 전에 수정할 수 있습니다.

**Topics**
+ [콘솔에서 테이블 선택 및 변환 규칙 지정](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md)
+ [JSON을 사용하여 테이블 선택 및 변환 지정](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.md)
+ [선택 규칙 및 작업](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md)
+ [테이블 매핑의 와일드카드](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md)
+ [변환 규칙 및 작업](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)
+ [변환 규칙 표현식을 사용하여 열 내용 정의](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md)
+ [테이블 및 컬렉션 설정 규칙과 작업](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md)
+ [데이터 마스킹을 사용하여 민감한 정보 숨기기](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.md)

**참고**  
MongoDB 소스 엔드포인트에 대한 테이블 매핑 작업을 수행하는 경우, 필터를 사용하여 복제할 데이터를 지정하고 `schema_name` 대신 데이터베이스 이름을 지정할 수 있습니다. 아니면 기본 `"%"`를 사용할 수 있습니다.

# 콘솔에서 테이블 선택 및 변환 규칙 지정
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.Console"></a>

 AWS Management Console 를 사용하여 테이블 선택 및 변환 지정을 포함하여 테이블 매핑을 수행할 수 있습니다. 콘솔에서 **위치** 섹션을 사용하여 스키마, 테이블, 작업을 지정합니다(포함 또는 제외). **필터** 섹션을 사용하여 테이블에서 열 이름과 복제 작업에 적용할 조건을 지정합니다. 이와 함께 이 두 작업은 선택 규칙을 생성합니다.

1개 이상의 선택 규칙을 지정한 후 테이블 매핑에 변환을 포함시킬 수 있습니다. 변환을 사용하여 스키마나 테이블 이름을 변경하거나, 스키마나 테이블에 접두사나 접미사를 추가하거나, 또는 테이블 열을 제거할 수 있습니다.

**참고**  
AWS DMS 는 스키마 수준, 테이블 수준 또는 열 수준당 둘 이상의 변환 규칙을 지원하지 않습니다.

다음 절차에서는 **EntertainmentAgencySample**이라는 스키마에서 호출된 **Customers**라는 테이블을 기반으로 선택 규칙을 설정하는 방법을 보여줍니다.

**콘솔을 사용하여 테이블 선택, 필터 기준, 변환을 지정하려면**

1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/dms/v2/](https://console.aws.amazon.com/dms/v2/) AWS DMS 콘솔을 엽니다.

   IAM 사용자로 로그인한 경우, AWS DMS에 액세스하려면 적절한 권한이 있어야 합니다. 필요한 권한에 관한 자세한 내용은 [를 사용하는 데 필요한 IAM 권한 AWS DMS](security-iam.md#CHAP_Security.IAMPermissions) 섹션을 참조하세요.

1. **대시보드** 페이지에서 **데이터베이스 마이그레이션 작업**을 선택합니다.

1. **작업 생성**을 선택합니다.

1. **작업 구성** 섹션에서 **작업 식별자**, **복제 인스턴스**, **소스 데이터베이스 엔드포인트**, **대상 데이터베이스 엔드포인트**, **마이그레이션 유형** 등의 작업 정보를 입력합니다.  
![\[스키마 및 테이블 선택\]](http://docs.aws.amazon.com/ko_kr/dms/latest/userguide/images/datarep-create-task-20.png)

1. **테이블 매핑** 섹션에서 스키마 이름과 테이블 이름을 입력합니다. 스키마 이름 또는 테이블 이름을 지정할 때 "%"를 와일드카드 값으로 사용할 수 있습니다. 사용할 수 있는 다른 와일드카드에 관한 자세한 내용은 [테이블 매핑의 와일드카드](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md)을 참조하세요. 수행할 작업을 지정하여 필터에서 정의한 데이터를 포함하거나 제외합니다.  
![\[스키마 및 테이블 선택\]](http://docs.aws.amazon.com/ko_kr/dms/latest/userguide/images/datarep-Tasks-selecttransfrm.png)

1. **열 필터 추가**와 **조건 추가** 링크를 사용하여 필터 정보를 지정합니다.

   1. **열 필터 추가**를 선택하여 열과 조건을 지정합니다.

   1. **조건 추가**를 선택하여 조건을 추가할 수 있습니다.

    다음은 **01** 및 **85** 사이에 **AgencyIDs**를 포함하는 **Customers** 테이블에 대한 필터를 보여주는 예입니다.  
![\[스키마 및 테이블 선택\]](http://docs.aws.amazon.com/ko_kr/dms/latest/userguide/images/datarep-Tasks-filter.png)

1. 원하는 대로 선택하고 **새 선택 규칙 추가**를 선택합니다.

1. 최소 1개 이상의 선택 규칙을 생성한 후 작업에 변환을 추가할 수 있습니다. **변환 규칙 추가**를 선택합니다.  
![\[변환 규칙\]](http://docs.aws.amazon.com/ko_kr/dms/latest/userguide/images/datarep-Tasks-transform1.png)

1. 변환할 대상을 선택하고 요청된 추가 정보를 입력합니다. 다음은 **Customer** 테이블에서 **AgencyStatus** 열을 삭제하는 변환을 보여주는 예입니다.  
![\[변환 규칙\]](http://docs.aws.amazon.com/ko_kr/dms/latest/userguide/images/datarep-Tasks-transform2.png)

1. **변환 규칙 추가**를 선택합니다.

1. **작업 생성**을 선택합니다.

**참고**  
AWS DMS 는 스키마 수준, 테이블 수준 또는 열 수준당 둘 이상의 변환 규칙을 지원하지 않습니다.

# JSON을 사용하여 테이블 선택 및 변환 지정
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation"></a>

마이그레이션 중에 적용할 테이블 매핑을 지정하려면 JSON 파일을 만들 수 있습니다. 콘솔을 사용하여 마이그레이션 작업을 만드는 경우, 이 JSON 파일을 찾아보거나 JSON을 테이블 매핑 상자에 직접 입력할 수 있습니다. CLI 또는 API를 사용하여 마이그레이션을 수행하는 경우, `CreateReplicationTask` 또는 `ModifyReplicationTask` API 작업의 `TableMappings` 파라미터를 사용하여 이 파일을 지정할 수 있습니다.

AWS DMS 는 최대 2MB 크기의 테이블 매핑 JSON 파일만 처리할 수 있습니다. DMS 작업을 수행하는 동안에는 매핑 규칙 JSON 파일 크기를 2MB 미만으로 유지하는 것이 좋습니다. 이렇게 하면 작업 생성 또는 수정 중에 예상치 못한 오류가 발생하지 않습니다. 매핑 규칙 파일이 2MB 제한을 초과하는 경우, 테이블을 여러 작업으로 분할하여 매핑 규칙 파일이 이 한도 이하로 유지되도록 크기를 줄이는 것이 좋습니다.

사용할 테이블, 뷰 및 스키마를 지정할 수 있습니다. 또한 테이블, 뷰 및 스키마 변환을 수행하고 AWS DMS 에서 개별 테이블 및 뷰를 로드하는 방법에 대한 설정을 지정할 수 있습니다. 다음 규칙 유형을 사용하여 이러한 옵션에 대한 테이블 매핑 규칙을 만듭니다.
+ `selection` 규칙 – 로드할 소스 테이블, 뷰 및 스키마의 유형과 이름을 식별합니다. 자세한 내용은 [선택 규칙 및 작업](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md) 단원을 참조하십시오.
+ `transformation` 규칙 – 대상에 로드되기 전에 소스의 특정 소스 테이블 및 스키마에 대한 특정 변경 사항 또는 추가 사항을 지정합니다. 자세한 내용은 [변환 규칙 및 작업](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md) 단원을 참조하십시오.

  또한 변환 규칙 내에서 표현식을 사용하여 새 열과 기존 열의 내용을 정의할 수 있습니다. 자세한 내용은 [변환 규칙 표현식을 사용하여 열 내용 정의](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md) 단원을 참조하십시오.
+ `table-settings` 규칙 – DMS 작업이 개별 테이블에 대한 데이터를 로드하는 방법을 지정합니다. 자세한 내용은 [테이블 및 컬렉션 설정 규칙과 작업](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md) 단원을 참조하십시오.

**참고**  
Amazon S3 대상의 경우, `post-processing` 규칙 유형과 `add-tag` 규칙 작업을 사용하여 선택된 테이블 및 스키마로 매핑된 S3 객체에 태그를 지정할 수도 있습니다. 자세한 내용은 [Amazon S3 객체 태그 지정](CHAP_Target.S3.md#CHAP_Target.S3.Tagging) 단원을 참조하십시오.  
다음 대상의 경우 `object-mapping` 규칙 유형을 사용하여 선택한 스키마와 테이블을 대상으로 마이그레이션하는 방법과 위치를 지정할 수 있습니다.  
Amazon DynamoDB – 자세한 내용은 [객체 매핑을 사용하여 데이터를 DynamoDB로 마이그레이션](CHAP_Target.DynamoDB.md#CHAP_Target.DynamoDB.ObjectMapping)을 참조하세요.
Amazon Kinesis – 자세한 내용은 [객체 매핑을 사용하여 데이터를 Kinesis 데이터 스트림으로 마이그레이션](CHAP_Target.Kinesis.md#CHAP_Target.Kinesis.ObjectMapping)을 참조하세요.
Apache Kafka – 자세한 내용은 [객체 매핑을 사용하여 데이터를 Kafka 주제로 마이그레이션](CHAP_Target.Kafka.md#CHAP_Target.Kafka.ObjectMapping)을 참조하세요.

# 선택 규칙 및 작업
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections"></a>

테이블 매핑을 사용하여 사용할 테이블, 뷰 및 스키마를 지정하기 위해 선택 규칙과 작업을 이용할 수 있습니다. 선택 규칙 유형을 사용하는 테이블 매핑 규칙의 경우, 다음 값을 적용할 수 있습니다.

**주의**  
이러한 규칙 내에 민감한 데이터를 포함하지 마세요.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.html)

**Example 스키마에서 모든 테이블 마이그레이션**  
다음은 소스에서 이름이 `Test`인 스키마의 모든 테이블을 대상 엔드포인트로 마이그레이션하는 예입니다.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            },
            "rule-action": "include"
        }
    ]
}
```

**Example 스키마에서 일부 테이블 마이그레이션**  
다음은 소스에서 이름이 `Test`인 스키마에서 `DMS`로 시작하는 테이블을 제외한 모든 테이블을 대상 엔드포인트로 마이그레이션하는 예입니다.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "selection",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "DMS%"
            },
            "rule-action": "exclude"
        }
    ]
}
```

**Example 단일 스키마에서 지정된 단일 테이블 마이그레이션**  
다음은 소스의 `NewCust` 스키마에서 `Customer` 테이블을 대상 엔드포인트로 마이그레이션하는 예입니다.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "NewCust",
                "table-name": "Customer"
            },
            "rule-action": "explicit"
        }
    ]
}
```
여러 선택 규칙을 지정하여 여러 테이블 및 스키마에서 명시적으로 선택할 수 있습니다.

**Example 설정된 순서대로 테이블 마이그레이션**  
테이블과 뷰는 로드 순서 값에 따라 마이그레이션되며, 값이 높을수록 마이그레이션 시퀀스에서 우선 순위를 받습니다. 다음 예제에서는 우선 순위 값이 2인 `loadfirst`, 우선 순위 값이 1인 `loadsecond`, 두 테이블을 마이그레이션합니다. 마이그레이션 작업은 `loadsecond` 테이블로 진행하기 전에 먼저 `loadfirst` 테이블을 처리합니다. 이 우선 순위 지정 메커니즘을 사용하면 마이그레이션 프로세스 중에 데이터베이스 객체 간의 종속성을 준수할 수 있습니다.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "loadsecond"
            },
            "rule-action": "include",
            "load-order": "1"
        },
        {
            "rule-type": "selection",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "loadfirst"
            },
            "rule-action": "include",
            "load-order": "2"
        }
    ]
}
```

**참고**  
`load-order`는 테이블 초기화에 적용됩니다. `MaxFullLoadSubTasks`가 1보다 큰 경우 연속 테이블 로드는 이전 테이블 로드가 완료될 때까지 기다리지 않습니다.

**Example 스키마에서 일부 뷰 마이그레이션**  
다음은 소스에서 이름이 `Test`인 스키마의 일부 뷰를 대상의 동등한 테이블로 마이그레이션하는 예입니다.  

```
{
   "rules": [
        {
           "rule-type": "selection",
           "rule-id": "2",
           "rule-name": "2",
           "object-locator": {
               "schema-name": "Test",
               "table-name": "view_DMS%",
               "table-type": "view"
            },
           "rule-action": "include"
        }
    ]
}
```

**Example 스키마에서 모든 테이블 및 뷰 마이그레이션**  
다음은 소스에서 이름이 `report`인 스키마의 모든 테이블 및 뷰를 대상의 동등한 테이블로 마이그레이션하는 예입니다.  

```
{
   "rules": [
        {
           "rule-type": "selection",
           "rule-id": "3",
           "rule-name": "3",
           "object-locator": {
               "schema-name": "report",
               "table-name": "%",
               "table-type": "all"
            },
           "rule-action": "include"
        }
    ]
}
```

# 테이블 매핑의 와일드카드
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards"></a>

이 섹션에서는 테이블 매핑을 위한 스키마와 테이블 이름을 지정할 때 사용할 수 있는 와일드카드에 대해 설명합니다.


| 와일드카드 | 일치 항목 | 
| --- |--- |
| % | Zero or more characters | 
| \$1 | A single character | 
| [\$1] | A literal underscore character | 
| [ab] | A set of characters. For example, [ab] matches either 'a' or 'b'. | 
| [a-d] | A range of characters. For example,[a-d] matches either 'a', 'b', 'c', or 'd'. | 

Oracle 소스 및 대상 엔드포인트의 경우, `escapeCharacter` 추가 연결 속성을 사용하여 이스케이프 문자를 지정할 수 있습니다. 이스케이프 문자를 사용하면 와일드카드 문자를 와일드카드가 아닌 것처럼 표현식에 사용할 수 있습니다. 예를 들어, `escapeCharacter=#`를 사용하면 이 샘플 코드에서처럼 표현식에 '\$1'을 사용하여 와일드카드 문자가 일반 문자로 작동하도록 할 수 있습니다.

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "542485267",
            "rule-name": "542485267",
            "object-locator": { "schema-name": "ROOT", "table-name": "TEST#_T%" },
            "rule-action": "include",
            "filters": []
        }
    ]
}
```

여기서 '\$1' 이스케이프 문자는 '\$1' 와일드카드 문자를 일반 문자로 만듭니다.는 스키마에서 테이블을 AWS DMS 선택합니다. `ROOT`여기서 각 테이블의 이름은 접두사`TEST_T`로가 붙습니다.

# 변환 규칙 및 작업
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations"></a>

변환 작업을 사용하여 선택한 스키마, 테이블 또는 뷰에 적용할 변환을 지정합니다. 변환 규칙은 선택적입니다.

## 제한 사항
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.Limitations"></a>
+ 동일한 객체(스키마, 테이블, 열, 테이블-테이블스페이스 또는 인덱스-테이블스페이스)에 대해 둘 이상의 변환 규칙 작업을 적용할 수 없습니다. 각 변형 작업이 서로 다른 객체에 적용되는 한, 모든 레벨에 여러 변환 규칙 작업을 적용할 수 있습니다. 그러나 동일한 열에 대해 `ADD-COLUMN` 또는 `CHANGE-DATA-TYPE`와 같은 다른 변환을 수행할 수 있는 데이터 마스킹 변환 규칙을 사용할 때는 이 제한이 적용되지 않습니다.
+ 변환 규칙의 테이블 이름과 열 이름은 대소문자를 구분합니다. 예를 들어, Oracle 또는 Db2 데이터베이스의 테이블 이름과 열 이름을 대문자로 제공해야 합니다.
+ 오른쪽에서 왼쪽으로 쓰는 언어를 사용하는 열 이름에는 변환이 지원되지 않습니다.
+ 이름에 특수 문자(예: \$1, \$1, /, -)가 포함된 열에서는 변환을 수행할 수 없습니다.
+ BLOB/CLOB 데이터 형식에 매핑된 열에 대해 지원되는 유일한 변환은 대상에서 열을 삭제하는 것입니다.
+ AWS DMS 는 두 소스 테이블을 단일 대상 테이블로 복제하는 것을 지원하지 않습니다.는 AWS DMS 복제 작업의 변환 규칙에 따라 테이블에서 테이블로, 열에서 열로 레코드를 복제합니다. 객체 이름은 중복되지 않도록 고유한 이름이어야 합니다.

  예를 들어, 소스 테이블에는 이름이 `ID`인 열이 있고 그에 상응하는 대상 테이블에는 `id`라는 기존 열이 있습니다. 하나의 규칙에서 `ADD-COLUMN` 문을 사용하여 `id`라는 새 열을 추가하고 SQLite 문을 사용하여 열을 사용자 지정 값으로 채우는 경우, 이름이 `id`인 모호한 중복 객체가 생성되며 이 객체는 지원되지 않습니다.
+ 변환 규칙을 생성할 때는 예를 들어 `column-name`를 `%`로 설정할 때 선택 규칙이 여러 열을 지정하는 경우에만 `data-type` 파라미터를 사용하는 것이 좋습니다. `data-type`을 사용하여 단일 열을 선택하는 것은 권장하지 않습니다.
+ AWS DMS 는 소스 객체와 대상 객체(테이블)가 동일한 데이터베이스/스키마에 있는 변환 규칙을 지원하지 않습니다. 변환 규칙에서 소스 및 대상과 동일한 테이블을 사용하면 테이블 데이터의 의도하지 않은 변경, 테이블 구조 수정 또는 테이블 삭제를 포함하되 이에 국한되지 않는 예기치 않고 잠재적으로 유해한 결과가 발생할 수 있습니다.

## 값
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.Values"></a>

변환 규칙 유형을 사용하는 테이블 매핑 규칙의 경우, 다음 값을 적용할 수 있습니다.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.html)

## 예제
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.Examples"></a>

**Example 스키마 이름 바꾸기**  
다음은 소스의 스키마 이름 `Test`를 대상의 `Test1`로 변경하는 예입니다.  

```
{

    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "transformation",
            "rule-id": "2",
            "rule-name": "2",
            "rule-action": "rename",
            "rule-target": "schema",
            "object-locator": {
                "schema-name": "Test"
            },
            "value": "Test1"
        }
    ]
}
```

**Example 테이블 이름 바꾸기**  
다음은 소스의 테이블 이름 `Actor`를 대상의 `Actor1`로 변경하는 예입니다.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "transformation",
            "rule-id": "2",
            "rule-name": "2",
            "rule-action": "rename",
            "rule-target": "table",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "Actor"
            },
            "value": "Actor1"
        }
    ]
}
```

**Example 열 이름 바꾸기**  
다음은 `Actor` 테이블에서 소스의 열 이름 `first_name`을 대상의 `fname`으로 변경하는 예입니다.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "test",
                "table-name": "%"
            },
            "rule-action": "include"
        },
         {
            "rule-type": "transformation",
            "rule-id": "4",
            "rule-name": "4",
            "rule-action": "rename",
            "rule-target": "column",
            "object-locator": {
                "schema-name": "test",
                "table-name": "Actor",
                "column-name" : "first_name"
            },
            "value": "fname"
        }
    ]
}
```

**Example Oracle 테이블 테이블스페이스의 이름 바꾸기**  
다음은 Oracle 소스에서 `Actor`라는 테이블에 대해 `SetSpace`라는 테이블 테이블스페이스의 이름을 Oracle 대상 엔드포인트의 `SceneTblSpace`로 바꾸는 예입니다.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Play",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "transformation",
            "rule-id": "2",
            "rule-name": "2",
            "rule-action": "rename",
            "rule-target": "table-tablespace",
            "object-locator": {
                "schema-name": "Play",
                "table-name": "Actor",
                "table-tablespace-name": "SetSpace"
            },
            "value": "SceneTblSpace"
        }
    ]
}
```

**Example Oracle 인덱스 테이블스페이스의 이름 바꾸기**  
다음은 Oracle 소스에서 `Actor`라는 테이블에 대해 `SetISpace`라는 인덱스 테이블스페이스의 이름을 Oracle 대상 엔드포인트의 `SceneIdxSpace`로 바꾸는 예입니다.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Play",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "transformation",
            "rule-id": "2",
            "rule-name": "2",
            "rule-action": "rename",
            "rule-target": "table-tablespace",
            "object-locator": {
                "schema-name": "Play",
                "table-name": "Actor",
                "table-tablespace-name": "SetISpace"
            },
            "value": "SceneIdxSpace"
        }
    ]
}
```

**Example 열 추가**  
다음 예에서는 스키마 `test`의 테이블 `Actor`에 `datetime` 열을 추가합니다.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "test",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "transformation",
            "rule-id": "2",
            "rule-name": "2",
            "rule-action": "add-column",
            "rule-target": "column",
            "object-locator": {
                "schema-name": "test",
                "table-name": "actor"
            },
            "value": "last_updated",
            "data-type": {
                "type": "datetime",
                "precision": 6
            }
        }
    ]
}
```

**Example 열 제거**  
다음은 소스의 `Actor`라는 테이블을 변환하여 `col` 문자로 시작하는 모든 열을 대상에서 제거하는 예입니다.  

```
{
 	"rules": [{
		"rule-type": "selection",
		"rule-id": "1",
		"rule-name": "1",
		"object-locator": {
			"schema-name": "test",
			"table-name": "%"
		},
		"rule-action": "include"
	}, {
		"rule-type": "transformation",
		"rule-id": "2",
		"rule-name": "2",
		"rule-action": "remove-column",
		"rule-target": "column",
		"object-locator": {
			"schema-name": "test",
			"table-name": "Actor",
			"column-name": "col%"
		}
	}]
 }
```

**Example 소문자로 변환**  
다음은 소스의 테이블 이름 `ACTOR`를 대상의 `actor`로 변환하는 예입니다.  

```
{
	"rules": [{
		"rule-type": "selection",
		"rule-id": "1",
		"rule-name": "1",
		"object-locator": {
			"schema-name": "test",
			"table-name": "%"
		},
		"rule-action": "include"
	}, {
		"rule-type": "transformation",
		"rule-id": "2",
		"rule-name": "2",
		"rule-action": "convert-lowercase",
		"rule-target": "table",
		"object-locator": {
			"schema-name": "test",
			"table-name": "ACTOR"
		}
	}]
}
```

**Example 대문자로 변환**  
다음은 모든 테이블의 전체 열과 모든 스키마를 소스의 소문자에서 대상의 대문자로 변환하는 예제입니다.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "test",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "transformation",
            "rule-id": "2",
            "rule-name": "2",
            "rule-action": "convert-uppercase",
            "rule-target": "column",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%",
                "column-name": "%"
            }
        }
    ]
}
```

**Example 접두사 추가**  
다음은 소스의 모든 테이블을 변환하여 대상에서 테이블에 `DMS_` 접두사를 추가하는 예입니다.  

```
{
 	"rules": [{
		"rule-type": "selection",
		"rule-id": "1",
		"rule-name": "1",
		"object-locator": {
			"schema-name": "test",
			"table-name": "%"
		},
		"rule-action": "include"
	}, {
		"rule-type": "transformation",
		"rule-id": "2",
		"rule-name": "2",
		"rule-action": "add-prefix",
		"rule-target": "table",
		"object-locator": {
			"schema-name": "test",
			"table-name": "%"
		},
		"value": "DMS_"
	}]
 
}
```

**Example 접두사 바꾸기**  
다음은 소스에서 `Pre_` 접두사를 포함하는 모든 열을 변환하여 이 접두사를 대상의 `NewPre_` 접두사로 대체하는 예입니다.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "test",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "transformation",
            "rule-id": "2",
            "rule-name": "2",
            "rule-action": "replace-prefix",
            "rule-target": "column",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%",
                "column-name": "%"
            },
            "value": "NewPre_",
            "old-value": "Pre_"
        }
    ]
}
```

**Example 접미사 제거**  
다음은 소스의 모든 테이블을 변환하여 대상의 테이블에서 `_DMS` 접미사를 제거하는 예입니다.  

```
{
	"rules": [{
		"rule-type": "selection",
		"rule-id": "1",
		"rule-name": "1",
		"object-locator": {
			"schema-name": "test",
			"table-name": "%"
		},
		"rule-action": "include"
	}, {
		"rule-type": "transformation",
		"rule-id": "2",
		"rule-name": "2",
		"rule-action": "remove-suffix",
		"rule-target": "table",
		"object-locator": {
			"schema-name": "test",
			"table-name": "%"
		},
		"value": "_DMS"
	}]
}
```

**Example 프라이머리 키 정의**  
대상 엔드포인트로 마이그레이션된 `ITEM-primary-key` 테이블의 세 열에서 `ITEM`라는 프라이머리 키를 정의하는 예입니다.  

```
{
	"rules": [{
		"rule-type": "selection",
		"rule-id": "1",
		"rule-name": "1",
		"object-locator": {
			"schema-name": "inventory",
			"table-name": "%"
		},
		"rule-action": "include"
	}, {
		"rule-type": "transformation",
		"rule-id": "2",
		"rule-name": "2",
		"rule-action": "define-primary-key",
		"rule-target": "table",
		"object-locator": {
			"schema-name": "inventory",
			"table-name": "ITEM"
		},
		"primary-key-def": {
			"name": "ITEM-primary-key",
			"columns": [
				"ITEM-NAME",
				"BOM-MODEL-NUM",
				"BOM-PART-NUM"
			]
              }
	}]
}
```

**Example 고유 인덱스 정의**  
대상 엔드포인트로 마이그레이션된 `ITEM` 테이블의 세 열에서 `ITEM-unique-idx`라는 고유 인덱스를 정의하는 예입니다.  

```
{
	"rules": [{
		"rule-type": "selection",
		"rule-id": "1",
		"rule-name": "1",
		"object-locator": {
			"schema-name": "inventory",
			"table-name": "%"
		},
		"rule-action": "include"
	}, {
		"rule-type": "transformation",
		"rule-id": "2",
		"rule-name": "2",
		"rule-action": "define-primary-key",
		"rule-target": "table",
		"object-locator": {
			"schema-name": "inventory",
			"table-name": "ITEM"
		},
		"primary-key-def": {
			"name": "ITEM-unique-idx",
			"origin": "unique-index",
			"columns": [
				"ITEM-NAME",
				"BOM-MODEL-NUM",
				"BOM-PART-NUM"
			]
              }
	}]
}
```

**Example 대상 열의 데이터 형식 변경**  
다음 예제에서는 이름이 `SALE_AMOUNT`인 대상 열의 데이터 형식을 기존 데이터 형식에서 `int8`로 변경합니다.  

```
{
    "rule-type": "transformation",
    "rule-id": "1",
    "rule-name": "RuleName 1",
    "rule-action": "change-data-type",
    "rule-target": "column",
    "object-locator": {
        "schema-name": "dbo",
        "table-name": "dms",
        "column-name": "SALE_AMOUNT"
    },
    "data-type": {
        "type": "int8"
    }
}
```

**Example 이전 이미지 열 추가**  
`emp_no`라는 소스 열에 대해 다음 예의 변환 규칙은 대상에 `BI_emp_no`라는 새 열을 추가합니다.  

```
{
	"rules": [{
			"rule-type": "selection",
			"rule-id": "1",
			"rule-name": "1",
			"object-locator": {
				"schema-name": "%",
				"table-name": "%"
			},
			"rule-action": "include"
		},
		{
			"rule-type": "transformation",
			"rule-id": "2",
			"rule-name": "2",
			"rule-target": "column",
			"object-locator": {
				"schema-name": "%",
				"table-name": "employees"
			},
			"rule-action": "add-before-image-columns",
			"before-image-def": {
				"column-prefix": "BI_",
				"column-suffix": "",
				"column-filter": "pk-only"
			}
		}
	]
}
```
여기서 다음 문은 해당 행의 `BI_emp_no` 열을 1로 채웁니다.  

```
UPDATE employees SET emp_no = 3 WHERE BI_emp_no = 1;
```
지원되는 AWS DMS 대상에 CDC 업데이트를 작성할 때 `BI_emp_no` 열을 사용하면 `emp_no` 열에 업데이트된 값이 있는 행을 알 수 있습니다.

# 변환 규칙 표현식을 사용하여 열 내용 정의
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions"></a>

변환 규칙 내에서 표현식을 사용하여 새 열과 기존 열의 내용을 정의할 수 있습니다. 예를 들어, 표현식을 사용하여 열을 추가하거나 소스 테이블 헤더를 대상에 복제할 수 있습니다. 표현식을 사용하여 대상 테이블의 레코드를 소스에서 삽입, 업데이트 또는 삭제된 것으로 플래그를 지정할 수도 있습니다.

**Topics**
+ [표현식을 사용하여 열 추가](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-adding)
+ [표현식을 사용하여 대상 레코드에 플래그 지정](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Flagging)
+ [표현식을 사용하여 소스 테이블 헤더 복제](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Headers)
+ [SQLite 함수를 사용하여 표현식 작성](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite)
+ [표현식을 사용하여 대상 테이블에 메타데이터 추가](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Metadata)

## 표현식을 사용하여 열 추가
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-adding"></a>

변환 규칙에서 표현식을 사용하여 테이블에 열을 추가하려면 `add-column` 규칙 작업 및 `column` 규칙 대상을 사용합니다.

다음 예에서는 `ITEM` 테이블에 새 열을 추가합니다. 50자 길이의 `string` 데이터 형식을 사용하여 새 열 이름을 `FULL_NAME`으로 설정합니다. 표현식은 기존의 두 열 `FIRST_NAME` 및 `LAST_NAME`의 값을 결합하여 `FULL_NAME`으로 평가합니다. `schema-name`, `table-name` 및 표현식 파라미터는 소스 데이터베이스 테이블의 객체를 참조합니다. `Value` 및 `data-type`블록은 대상 데이터베이스 테이블의 객체를 참조합니다.

```
{
    "rules": [
        {
            "rule-type": "selection", 
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "transformation",
            "rule-id": "2",
            "rule-name": "2",
            "rule-action": "add-column",
            "rule-target": "column",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "ITEM"
            },
            "value": "FULL_NAME",
            "expression": "$FIRST_NAME||'_'||$LAST_NAME",
            "data-type": {
                 "type": "string",
                 "length": 50
            }
        }
    ]
}
```

## 표현식을 사용하여 대상 레코드에 플래그 지정
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Flagging"></a>

변환 규칙에서 표현식을 사용하여 대상 테이블의 레코드를 소스 테이블에서 삽입, 업데이트 또는 삭제된 것으로 플래그를 지정할 수 있습니다. 표현식은 `operation_indicator` 함수를 사용하여 레코드에 플래그를 지정합니다. 소스에서 삭제된 레코드는 대상에서 삭제되지 않습니다. 그 대신, 대상 레코드가 소스에서 삭제되었음을 나타내는 사용자 제공 값으로 플래그가 지정됩니다.

**참고**  
이 `operation_indicator` 함수는 원본 및 대상 데이터베이스에 프라이머리 키가 있는 테이블에서만 작동합니다.

예를 들어, 다음 변환 규칙은 먼저 대상 테이블에 새 `Operation` 열을 추가합니다. 그런 다음, 레코드가 소스 테이블에서 삭제될 때마다 `D` 값으로 열을 업데이트합니다.

```
{
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "%",
        "table-name": "%"
      },
      "rule-action": "add-column",
      "value": "Operation",
      "expression": "operation_indicator('D', 'U', 'I')",
      "data-type": {
        "type": "string",
        "length": 50
      }
}
```

## 표현식을 사용하여 소스 테이블 헤더 복제
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Headers"></a>

기본적으로 소스 테이블의 헤더는 대상에 복제되지 않습니다. 복제할 헤더를 나타내려면 테이블 열 헤더를 포함하는 표현식과 함께 변환 규칙을 사용합니다.

표현식에서 다음 열 헤더를 사용할 수 있습니다.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.html)

다음 예에서는 소스의 스트림 위치 값을 사용하여 대상에 새 열을 추가합니다. SQL Server의 경우, 스트림 위치 값은 소스 엔드포인트의 LSN입니다. Oracle의 경우, 스트림 위치 값은 소스 엔드포인트의 SCN입니다.

```
{
      "rule-type": "transformation",
     "rule-id": "2",
      "rule-name": "2",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "%",
        "table-name": "%"
      },
      "rule-action": "add-column",
      "value": "transact_id",
      "expression": "$AR_H_STREAM_POSITION",
      "data-type": {
        "type": "string",
        "length": 50
      }
    }
```

다음 예제에서는 원본의 고유한 증분 번호가 있는 새 열을 대상에 추가합니다. 이 값은 작업 수준에서 35자리 고유 숫자를 나타냅니다. 처음 16자리는 타임스탬프의 일부이고, 마지막 19자리는 DBMS에서 증분한 record\$1id 번호입니다.

```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "add-column",
"value": "transact_id",
"expression": "$AR_H_CHANGE_SEQ",
"data-type": {
"type": "string",
"length": 50
}
}
```

## SQLite 함수를 사용하여 표현식 작성
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite"></a>

테이블 설정을 사용하여 지정된 작업에서 선택한 테이블 또는 뷰에 적용할 설정을 지정합니다. 테이블 설정 규칙은 선택 사항입니다.

**참고**  
MongoDB 및 DocumentDB 데이터베이스는 테이블과 뷰의 개념 대신 데이터 레코드를 *컬렉션*에 함께 수집된 문서로 저장합니다. 따라서 MongoDB 또는 DocumentDB 소스에서 마이그레이션할 때는 테이블과 뷰보다는 선택한 *컬렉션*에 대한 병렬 로드 설정의 범위 세그먼트화 유형을 고려하세요.

**Topics**
+ [CASE 표현식 사용](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.CASE)
+ [예제:](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.Ex)

다음은 변환 규칙 표현식을 작성하는 데 사용할 수 있는 문자열 함수를 찾을 수 있습니다.


| 문자열 함수 | 설명 | 
| --- | --- | 
|  `lower(x)`  |  이 `lower(x)` 함수는 모든 문자가 소문자로 변환된 *`x`* 문자열의 복사본을 반환합니다. 기본 내장 `lower` 함수는 ASCII 문자에만 사용할 수 있습니다.  | 
|  `upper(x)`  |  이 `upper(x)` 함수는 모든 문자가 소문자로 변환된 *`x`* 문자열의 복사본을 반환합니다. 기본 내장 `upper` 함수는 ASCII 문자에만 사용할 수 있습니다.  | 
|  `ltrim(x,y)`  |  이 `ltrim(x,y)` 함수는 x의 왼쪽에서부터 y에 표시되는 모든 문자를 제거하여 구성된 문자열을 반환합니다. y에 값이 없는 경우, `ltrim(x)`는 x의 왼쪽에서 공백을 제거합니다.  | 
|  `replace(x,y,z)`  |  이 `replace(x,y,z)` 함수는 문자열 x에서 나타나는 모든 문자열 y를 문자열 z로 대체하여 구성된 문자열을 반환합니다.  | 
| `rtrim(x,y)` |  이 `rtrim(x,y)` 함수는 x의 오른쪽에서부터 y에 표시되는 모든 문자를 제거하여 구성된 문자열을 반환합니다. y에 값이 없는 경우, `rtrim(x)`는 x의 오른쪽에서 공백을 제거합니다.  | 
| `substr(x,y,z)` |  이 `substr(x,y,z)` 함수는 입력 문자열의 첫 `y`번째 문자로 시작하는 하위 문자열 `x`를 반환합니다. 이 문자열의 길이는 *`z`*자입니다. *`z`*를 생략하면 `substr(x,y)`은 `y`번째 문자로 시작하는 `x` 문자열의 끝까지 모든 문자를 반환합니다. `x`의 가장 왼쪽 문자는 숫자 1입니다. *`y`*가 음수인 경우, 왼쪽이 아닌 오른쪽부터 계수하여 하위 문자열의 첫 번째 문자를 찾습니다. *`z`*가 음수인 경우, 첫 `y` 번째 문자 앞의 `abs(z)` 문자가 반환됩니다. `x`가 문자열인 경우, 문자의 인덱스는 실제 UTF-8 문자를 참조합니다. `x`가 BLOB인 경우, 인덱스는 바이트를 나타냅니다.  | 
| trim(x,y) |  이 `trim(x,y)` 함수는 `x`의 양쪽에서부터 `y`에 표시되는 모든 문자를 제거하여 구성된 문자열을 반환합니다. `y`에 값이 없는 경우, `trim(x)`는 `x`의 오른쪽에서 공백을 제거합니다.  | 

다음은 변환 규칙 표현식을 작성하는 데 사용할 수 있는 LOB 함수를 찾을 수 있습니다.


| LOB 함수 | 설명 | 
| --- | --- | 
|  `hex(x)`  |  이 `hex` 함수는 BLOB를 인수로 받고 BLOB 내용의 대문자 16진수 문자열 버전을 반환합니다.  | 
|  `randomblob (N)`  |  이 `randomblob(N)` 함수는 의사 랜덤 바이트를 포함하는 `N`바이트 BLOB를 반환합니다. *N*이 1보다 작으면 1바이트 임의 BLOB가 반환됩니다.  | 
|  `zeroblob(N)`  |  이 `zeroblob(N)` 함수는 `N`바이트의 0x00으로 구성된 BLOB를 반환합니다.  | 

다음은 변환 규칙 표현식을 작성하는 데 사용할 수 있는 numeric 함수를 찾을 수 있습니다.


| Numeric 함수 | 설명 | 
| --- | --- | 
|  `abs(x)`  |  이 `abs(x)` 함수는 숫자 인수 `x`의 절대값을 반환합니다. *x*가 NULL인 경우 `abs(x)` 함수는 NULL을 반환합니다. **x**가 숫자 값으로 변환할 수 없는 문자열 또는 BLOB인 경우 `abs(x)` 함수는 0.0을 반환합니다.  | 
|  `random()`  |  이 `random` 함수는 -9,223,372,036,854,775,808 \$1 \$19,223,372,036,854,775,807 사이의 의사 랜덤 정수를 반환합니다.  | 
|  `round (x,y)`  |  이 `round (x,y)` 함수는 소수점 오른쪽의 *y*자리 숫자로 반올림된 부동 소수점 값 *x*를 반환합니다. *y*에 값이 없으면 0으로 간주됩니다.  | 
|  `max (x,y...)`  |  다중 인수 `max` 함수는 최대값이 포함된 인수를 반환하며 인수가 NULL이면 NULL을 반환합니다. `max` 함수는 인수의 왼쪽에서 오른쪽으로 데이터 정렬 함수를 정의하는 인수를 검색합니다. 검색으로 찾은 인수는 모든 문자열 비교에 해당 데이터 정렬 함수를 사용합니다. 데이터 정렬 함수를 정의하는 인수가 `max`에 하나도 없다면 `BINARY` 데이터 정렬 함수가 사용됩니다. `max` 함수는 인수가 두 개 이상이면 단순 함수이지만 인수가 하나뿐이면 집계 함수로 작동합니다.  | 
|  `min (x,y...)`  |  다중 인수 `min` 함수는 최소값이 포함된 인수를 반환합니다. `min` 함수는 인수의 왼쪽에서 오른쪽으로 데이터 정렬 함수를 정의하는 인수를 검색합니다. 검색으로 찾은 인수는 모든 문자열 비교에 해당 데이터 정렬 함수를 사용합니다. 데이터 정렬 함수를 정의하는 인수가 `min`에 하나도 없다면 `BINARY` 데이터 정렬 함수가 사용됩니다. `min` 함수는 인수가 두 개 이상이면 단순 함수이지만 인수가 하나뿐이면 집계 함수로 작동합니다.  | 

다음은 변환 규칙 표현식을 작성하는 데 사용할 수 있는 NULL 체크 함수를 찾을 수 있습니다.


| NULL 체크 함수 | 설명 | 
| --- | --- | 
|  `coalesce (x,y...)`  |  이 `coalesce` 함수는 NULL이 아닌 첫 번째 인수의 복사본을 반환하지만 모든 인수가 NULL이면 NULL을 반환합니다. coalesce 함수에는 인수가 두 개 이상 있습니다.  | 
|  `ifnull(x,y)`  |  이 `ifnull` 함수는 NULL이 아닌 첫 번째 인수의 복사본을 반환하지만 두 인수가 모두 NULL이면 NULL을 반환합니다. 이 `ifnull` 함수에는 정확히 두 개의 인수가 있습니다. `ifnull` 함수는 두 개의 인수가 있는 `coalesce`와 같은 함수입니다.  | 
|  `nullif(x,y)`  |  `nullif(x,y)` 함수는 인수가 다르면 첫 번째 인수의 복사본을 반환하지만 인수가 같으면 NULL을 반환합니다. `nullif(x,y)` 함수는 인수의 왼쪽에서 오른쪽으로 데이터 정렬 함수를 정의하는 인수를 검색합니다. 검색으로 찾은 인수는 모든 문자열 비교에 해당 데이터 정렬 함수를 사용합니다. 데이터 정렬 함수를 정의하는 인수가 nullif에 하나도 없다면 `BINARY` 데이터 정렬 함수가 사용됩니다.  | 

다음은 변환 규칙 표현식을 작성하는 데 사용할 수 있는 날짜 및 시간 함수를 찾을 수 있습니다.


| 날짜 및 시간 함수 | 설명 | 
| --- | --- | 
|  `date(timestring, modifier, modifier...)`  |  이 `date` 함수는 YYYY-MM-DD 형식으로 날짜를 반환합니다.  | 
|  `time(timestring, modifier, modifier...)`  |  이 `time` 함수는 HH:MM:SS 형식으로 시간을 반환합니다.  | 
|  `datetime(timestring, modifier, modifier...)`  |  이 `datetime` 함수는 YYYY-MM-DD HH:MM:SS 형식으로 날짜 및 시간을 반환합니다.  | 
|  `julianday(timestring, modifier, modifier...)`  |  이 `julianday` 함수는 기원전 4714년 11월 24일 그리니치에서 정오 이후 경과한 일수를 반환합니다.  | 
|  `strftime(format, timestring, modifier, modifier...)`  |  이 `strftime` 함수는 다음 변수 중 하나를 사용하여 첫 번째 인수로 지정된 형식 문자열에 따라 날짜를 반환합니다. `%d`: 날짜(월, 일) `%H`: 00\$124시 `%f`: \$1\$1 소수 초(SS.SSS) `%j`: 연중 일(001\$1366) `%J`: \$1\$1 율리우스력 날수 `%m`: 01\$112개월 차 `%M`: 00\$159분 `%s`: 1970-01-01 이후 경과 시간(초) `%S`: 00\$159초 `%w`: 주중 일(0\$16, 일요일 =0) `%W`: 연중 주(00\$153) `%Y`: 0000\$19999년도 `%%`: %  | 

다음은 변환 규칙 표현식을 작성하는 데 사용할 수 있는 해시 함수를 찾을 수 있습니다.


| 해시 함수 | 설명 | 
| --- | --- | 
|  `hash_sha256(x)`  |  이 `hash` 함수는 (SHA-256 알고리즘을 사용하여) 입력 열에 대한 해시 값을 생성하고 생성된 해시 값의 16진수 값을 반환합니다. 표현식에서 `hash` 함수를 사용하려면 표현식에 `hash_sha256(x)` 함수를 추가하고 *`x`*를 소스 열 이름으로 바꾸세요.  | 

### CASE 표현식 사용
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.CASE"></a>

SQLite `CASE` 표현식은 조건 목록을 평가하고 결과를 기반으로 표현식을 반환합니다. 다음 구문이 나와 있습니다.

```
    CASE case_expression
     WHEN when_expression_1 THEN result_1
     WHEN when_expression_2 THEN result_2
     ...
     [ ELSE result_else ] 
    END

# Or 

     CASE
     WHEN case_expression THEN result_1
     WHEN case_expression THEN result_2
     ...
     [ ELSE result_else ] 
    END
```

### 예제:
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.Ex"></a>

**Example CASE 조건을 사용하여 대상 테이블에 새 문자열 열을 추가하는 방법**  
예를 들어, 다음 변환 규칙은 먼저 대상 테이블 `employee`에 새 문자열 열 `emp_seniority`를 추가합니다. 급여 열에 SQLite `round` 함수를 사용하고 이 때 급여가 20,000과 같거나 이를 초과하는지 확인하는 CASE 조건을 함께 적용합니다. 값이 맞으면 해당 열에 값 `SENIOR`이 적용되고 다른 모든 항목은 해당 값 `JUNIOR`를 갖습니다.  

```
  {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-action": "add-column",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "public",
        "table-name": "employee"
      },
      "value": "emp_seniority",
      "expression": " CASE WHEN round($emp_salary)>=20000 THEN ‘SENIOR’ ELSE ‘JUNIOR’ END",
      "data-type": {
        "type": "string",
        "length": 50
      }

  }
```

**Example SUBSTR 함수를 사용하여 대상 테이블에 새 문자열 열을 추가하는 방법**  
다음 예제 변환 규칙은 SQLite 연산자 또는 함수를 사용하여 열에 데이터를 정의하는 새 문자열 열을 추가합니다. 이 접근 방식에는 SQLite 함수를 사용하여 Postgresql 대상 테이블에 삽입하기 전에 Oracle에서 UUID 형식으로 로드된 GUID 데이터를 변환하는 작업이 포함됩니다.  
다음 규칙은 SQLite 하위 문자열(SUBSTR), 16진수 함수(HEX) 및 소문자(LOWER) 함수를 사용하여 GUID 데이터를 하이픈으로 구분된 여러 그룹, 특히 8자리 그룹과 4자리 그룹 3개, 12자리 그룹 12자리 그룹으로 나눕니다. 총 32자리는 128비트를 나타냅니다.  
다음은 변환 규칙을 통한 대상 사후 처리에 대한 샘플 소스 데이터 및 출력입니다.  
**소스 테이블(Oracle GUID 형식)**    
T\$1COL2  

```
06F6949D234911EE80670242AC120002
1A2B3C4D5E6F11EE80670242AC120003
F5E4D3C2B1A011EE80670242AC120004
```
**대상 테이블(PostgreSQL UUID 형식)**    
T\$1COL2\$1TMP  

```
06f6949d-2349-11ee-8067-0242ac120002
1a2b3c4d-5e6f-11ee-8067-0242ac120003
f5e4d3c2-b1a0-11ee-8067-0242ac120004
```

```
{
  "rule-type": "transformation",
  "rule-id": "2",
  "rule-name": "2",
  "rule-action": "add-column",
  "rule-target": "column",
  "object-locator": {
    "schema-name": "SPORTS",
    "table-name": "TEST_TBL_2"
  },
  "value": "t_col2_tmp",
  "expression": "CASE LOWER(SUBSTR(HEX($T_COL2), 1, 8) || '-' || SUBSTR(HEX($T_COL2), 9, 4) || '-' || SUBSTR(HEX($T_COL2), 13, 4) || '-' || SUBSTR(HEX($T_COL2), 17, 4) || '-' || SUBSTR(HEX($T_COL2), 21, 12)) WHEN '----' THEN NULL ELSE LOWER(SUBSTR(HEX($T_COL2), 1, 8) || '-' || SUBSTR(HEX($T_COL2), 9, 4) || '-' || SUBSTR(HEX($T_COL2), 13, 4) || '-' || SUBSTR(HEX($T_COL2), 17, 4) || '-' || SUBSTR(HEX($T_COL2), 21, 12)) END",
  "data-type": {
    "type": "string",
    "length": 60
  }
}
```

**Example 대상 테이블에 새 날짜 열 추가**  
다음 예에서는 대상 테이블 `employee`에 새 날짜 열 `createdate`를 추가합니다. SQLite 날짜 함수 `datetime`을 사용하면 삽입된 각 행에 대해 새로 생성된 테이블에 날짜가 추가됩니다.  

```
  {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-action": "add-column",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "public",
        "table-name": "employee"
      },
      "value": "createdate",
      "expression": "datetime ()",
      "data-type": {
        "type": "datetime",
        "precision": 6
      }
  }
```

**Example 대상 테이블에 새 숫자 열 추가**  
다음 예에서는 대상 테이블 `employee`에 새 숫자 열 `rounded_emp_salary`를 추가합니다. SQLite `round` 함수를 사용하여 반올림된 급여를 추가합니다.  

```
  {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-action": "add-column",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "public",
        "table-name": "employee"
      },
      "value": "rounded_emp_salary",
      "expression": "round($emp_salary)",
      "data-type": {
        "type": "int8"
      }
  }
```

**Example 해시 함수를 사용하여 대상 테이블에 새 문자열 열을 추가하는 방법**  
다음 예에서는 대상 테이블 `employee`에 새 문자열 열 `hashed_emp_number`를 추가합니다. SQLite `hash_sha256(x)` 함수는 소스 열 `emp_number`의 대상에 해시된 값을 생성합니다.  

```
  {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-action": "add-column",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "public",
        "table-name": "employee"
      },
      "value": "hashed_emp_number",
      "expression": "hash_sha256($emp_number)",
      "data-type": {
        "type": "string",
        "length": 64
      }
  }
```

## 표현식을 사용하여 대상 테이블에 메타데이터 추가
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Metadata"></a>

다음 표현식을 사용하여 대상 테이블에 메타데이터 정보를 추가할 수 있습니다.
+ `$AR_M_SOURCE_SCHEMA` – 소스 스키마의 이름입니다.
+ `$AR_M_SOURCE_TABLE_NAME` – 소스 테이블의 이름입니다.
+ `$AR_M_SOURCE_COLUMN_NAME` – 소스 테이블의 열 이름입니다.
+ `$AR_M_SOURCE_COLUMN_DATATYPE` – 소스 테이블 내 열의 데이터 형식입니다.

**Example 소스의 스키마 이름을 사용하여 스키마 이름에 대한 열을 추가하는 방법**  
다음 예에서는 소스의 스키마 이름을 사용하여 대상에 `schema_name`이라는 새 열을 추가합니다.  

```
  {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-action": "add-column",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "%",
        "table-name": "%"
      },
      "rule-action": "add-column",
      "value":"schema_name",
      "expression": "$AR_M_SOURCE_SCHEMA", 
      "data-type": { 
         "type": "string",
         "length": 50
      }
  }
```

# 테이블 및 컬렉션 설정 규칙과 작업
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings"></a>

테이블 설정을 사용하여 지정된 작업에서 선택한 테이블 또는 뷰에 적용할 설정을 지정합니다. 테이블 설정 규칙은 엔드포인트 및 마이그레이션 요구 사항에 따라 선택 사항입니다.

MongoDB 및 Amazon DocumentDB 데이터베이스는 테이블과 뷰의 개념 대신 데이터 레코드를 *컬렉션*에 함께 수집된 문서로 저장합니다. MongoDB 또는 Amazon DocumentDB 엔드포인트에 대한 단일 데이터베이스는 데이터베이스 이름으로 식별되는 특정 컬렉션 집합입니다.

MongoDB 또는 Amazon DocumentDB 소스에서 마이그레이션할 때는 병렬 로드 설정을 사용하는 방식이 약간 다릅니다. 이 경우, 테이블과 뷰보다는 선택한 컬렉션에 대한 자동 세분화 또는 범위 세그먼트화 유형의 병렬 로드 설정을 고려해 보세요.

**Topics**
+ [테이블 설정의 와일드카드는 제한됨](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Wildcards)
+ [선택한 테이블, 뷰 및 컬렉션에 병렬 로드 사용](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad)
+ [선택한 테이블 또는 뷰의 LOB 설정 지정](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.LOB)
+ [테이블 설정 예제](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Examples)

테이블 설정 규칙 유형을 사용하는 테이블 매핑 규칙의 경우, 다음 파라미터를 적용할 수 있습니다.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)

## 테이블 설정의 와일드카드는 제한됨
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Wildcards"></a>

`"table-settings"` 규칙에 퍼센트 와일드카드(`"%"`)를 사용하는 것은 다음과 같이 소스 데이터베이스에서 지원되지 않습니다.

```
{
    "rule-type": "table-settings",
    "rule-id": "8",
    "rule-name": "8",
    "object-locator": {
        "schema-name": "ipipeline-prod",            
        "table-name": "%"
    },
    "parallel-load": {
        "type": "partitions-auto",
        "number-of-partitions": 16,
        "collection-count-from-metadata": "true",
        "max-records-skip-per-page": 1000000,
        "batch-size": 50000
    }
  }
```

다음과 같이 `"table-settings"` 규칙에 `"%"`를 사용하는 경우는 다음과 같은 예외를 AWS DMS 반환합니다.

```
Error in mapping rules. Rule with ruleId = x failed validation. Exact 
schema and table name required when using table settings rule.
```

또한에서 단일 작업을 사용하여 많은 수의 대용량 컬렉션을 로드하지 않는 것이 AWS 좋습니다`parallel-load`. 단, AWS DMS 는 `MaxFullLoadSubTasks` 작업 설정 파라미터의 값에 따라 동시에 로드되는 세그먼트 수는 물론, 리소스 경합도 제한하며 최대값은 49입니다.

그 대신 각 `"schema-name"` 및 `"table-name"`을 개별적으로 지정하여 가장 큰 컬렉션에 대한 소스 데이터베이스의 모든 컬렉션을 지정하세요. 또한 마이그레이션 규모를 적절하게 확장하세요. 예를 들어, 충분한 수의 복제 인스턴스에서 여러 작업을 실행하여 데이터베이스의 수많은 대규모 컬렉션을 처리할 수 있습니다.

## 선택한 테이블, 뷰 및 컬렉션에 병렬 로드 사용
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad"></a>

선택한 관계형 테이블, 뷰 및 컬렉션에 병렬 로드를 사용하여 마이그레이션 속도와 효율성을 향상시킬 수 있습니다. 즉, 여러 스레드를 동시에 사용하여 단일한 세그먼트화 테이블, 뷰 또는 컬렉션을 마이그레이션할 수 있습니다. 이를 위해는 전체 로드 작업을 스레드로 AWS DMS 분할하고 각 테이블 세그먼트를 자체 스레드에 할당합니다.

이 병렬 로드 프로세스를 사용하면 먼저 다중 스레드가 소스 엔드포인트에서 여러 테이블, 뷰 및 컬렉션을 동시에 언로드할 수 있습니다. 그런 다음, 여러 스레드가 동일한 테이블, 뷰 및 컬렉션을 대상 엔드포인트에 동시에 마이그레이션하고 로드할 수 있습니다. 일부 데이터베이스 엔진의 경우, 기존 파티션이나 하위 파티션별로 테이블 및 뷰를 세그먼트화할 수 있습니다. 다른 데이터베이스 엔진의 경우 특정 파라미터(자동 분할)에 따라 컬렉션을 AWS DMS 자동으로 분할할 수 있습니다. 그렇지 않으면 지정한 열 값의 범위로 테이블, 뷰 또는 컬렉션을 세그먼트화할 수 있습니다.

병렬 로드가 지원되는 소스 엔드포인트는 다음과 같습니다.
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM DB2 LUW
+ SAP Adaptive Server Enterprise(ASE)
+ MongoDB(병렬 전체 로드의 자동 세분화 및 범위 세그먼트화 옵션만 지원)
+ Amazon DocumentDB(병렬 전체 로드의 자동 세분화 및 범위 세그먼트화 옵션만 지원)

MongoDB 및 Amazon DocumentDB 엔드포인트의 경우는 병렬 전체 로드의 범위 분할 옵션에 대한 파티션 키인 열에 대해 다음 데이터 형식을 AWS DMS 지원합니다.
+ 배정밀도 실수
+ 문자열
+ ObjectId
+ 32비트 정수
+ 64비트 정수

테이블 설정 규칙과 함께 사용할 병렬 로드는 다음 대상 엔드포인트에 대해 지원됩니다.
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ Amazon S3
+ SAP Adaptive Server Enterprise(ASE)
+ Amazon Redshift
+ MongoDB(병렬 전체 로드의 자동 세분화 및 범위 세그먼트화 옵션만 지원)
+ Amazon DocumentDB(병렬 전체 로드의 자동 세분화 및 범위 세그먼트화 옵션만 지원)
+ Db2 LUW

동시에 로드할 최대 테이블 및 뷰 수를 지정하려면 `MaxFullLoadSubTasks` 작업 설정을 사용합니다.

병렬 로드 작업의 지원되는 대상에 대해 테이블 또는 뷰당 최대 스레드 수를 지정하려면 열-값 경계를 사용하여 더 많은 세그먼트를 정의하세요.

**중요**  
`MaxFullLoadSubTasks`는 동시에 로드할 테이블 또는 테이블 세그먼트의 수를 제어합니다. `ParallelLoadThreads`는 마이그레이션 작업에서 로드를 동시에 실행하는 데 사용하는 스레드의 수를 제어합니다. *이러한 설정은 배수로 적용됩니다*. 따라서 전체 로드 작업 중에 사용된 스레드의 총 개수는 대략 `ParallelLoadThreads `의 값에 `MaxFullLoadSubTasks`의 값을 곱한 결과(즉, `ParallelLoadThreads` **\$1** `MaxFullLoadSubtasks)`)입니다.  
전체 로드 하위 작업의 수가 많고 병렬 로드 스레드의 수가 많은 작업을 만들면 작업이 너무 많은 메모리를 소비하여 실패할 수 있습니다.

Amazon DynamoDB, Amazon Kinesis Data Streams, Apache Kafka 또는 Amazon Elasticsearch Service 대상의 테이블당 최대 스레드 수를 지정하려면 `ParallelLoadThreads` 대상 메타데이터 작업 설정을 사용하세요.

`ParallelLoadThreads` 사용 시 병렬 로드 작업의 버퍼 크기를 지정하려면 `ParallelLoadBufferSize` 대상 메타데이터 작업 설정을 사용합니다.

`ParallelLoadThreads` 및 `ParallelLoadBufferSize`의 가용성과 설정은 대상 엔드포인트에 따라 다릅니다.

`ParallelLoadThreads` 및 `ParallelLoadBufferSize` 설정에 관한 자세한 내용은 [대상 메타데이터 작업 설정](CHAP_Tasks.CustomizingTasks.TaskSettings.TargetMetadata.md)을 참조하세요. `MaxFullLoadSubTasks` 설정에 관한 자세한 내용은 [전체 로드 작업 설정](CHAP_Tasks.CustomizingTasks.TaskSettings.FullLoad.md)를 참조하세요. 대상 엔드포인트에 관한 자세한 내용은 관련 주제를 참조하세요.

병렬 로드를 사용하려면 `parallel-load` 옵션을 사용하여 `table-settings` 유형의 테이블 매핑 규칙을 만듭니다. `table-settings` 규칙 내에서 동시에 로드하려는 단일한 테이블, 뷰 또는 컬렉션의 세그먼트화 기준을 지정할 수 있습니다. 이렇게 하려면 `parallel-load` 옵션의 `type` 파라미터를 여러 옵션 중 하나로 설정합니다.

이러한 설정을 수행하는 방법은 병렬 로드를 위해 테이블, 뷰 또는 컬렉션을 세그먼트화하려는 방법에 따라 다릅니다.
+ 파티션별(세그먼트별) – `partitions-auto` 유형을 사용하여 기존 테이블 또는 뷰 파티션(세그먼트)을 모두 로드합니다. 또는 지정된 파티션 배열이 있는 `partitions-list` 유형을 사용하여 선택한 파티션만 로드합니다.

  MongoDB 및 Amazon DocumentDB 엔드포인트에만 `partitions-auto` 유형 및 추가 선택적 `table-settings` 파라미터를 사용하여가 AWS DMS 자동으로 계산하는 세그먼트별로 모든 또는 지정된 컬렉션을 로드합니다.
+ (Oracle 엔드포인트 전용) 하위 파티션별 – `subpartitions-auto` 유형을 사용하여 기존 테이블 또는 뷰 하위 파티션을 모두 로드합니다. 또는 지정된 `subpartitions` 배열이 있는 `partitions-list` 유형을 사용하여 선택한 하위 파티션만 로드합니다.
+ 정의한 세그먼트별 – 열-값 경계를 사용하여 정의한 테이블, 뷰 또는 컬렉션 세그먼트를 로드합니다. 이렇게 하려면 지정된 `ranges` 및 `columns` 배열이 있는 `boundaries` 유형을 사용하세요.
**참고**  
PostgreSQL 엔드포인트는 이러한 유형의 병렬 로드만 지원합니다. MongoDB와 Amazon DocumentDB는 소스 엔드포인트로 이 범위 세그먼트화 유형과 병렬 전체 로드(`partitions-auto`)의 자동 세분화 유형을 모두 지원합니다.

동시에 로드할 추가 테이블, 뷰 또는 컬렉션을 식별하려면 `parallel-load` 옵션을 사용하여 추가 `table-settings` 객체를 지정합니다.

다음 절차에서는 가장 간단한 것부터 가장 복잡한 것까지 각 병렬 로드 유형별로 JSON을 코드화하는 방법을 확인할 수 있습니다.

**모든 테이블, 뷰 또는 컬렉션 파티션이나 모든 테이블 또는 뷰 하위 파티션을 지정하려면**
+ `parallel-load`를 `partitions-auto` 유형 또는 `subpartitions-auto` 유형으로 지정하세요(동시 지정은 불가).

  그러면 모든 테이블, 뷰 또는 컬렉션 파티션(또는 세그먼트) 또는 하위 파티션이 자동으로 자체 스레드에 할당됩니다.

  일부 엔드포인트의 경우, 파티션 또는 하위 파티션은 테이블 또는 뷰에 이미 정의된 경우에만 병렬 로드에 포함됩니다. MongoDB 및 Amazon DocumentDB 소스 엔드포인트의 경우 선택적 추가 파라미터를 기반으로 파티션(또는 세그먼트)을 AWS DMS 자동으로 계산할 수 있습니다. 여기에는 `number-of-partitions`, `collection-count-from-metadata`, `max-records-skip-per-page`, `batch-size`가 포함됩니다.

**선택한 테이블 또는 뷰 파티션, 하위 파티션 또는 둘 다 지정하려면**

1. `partitions-list` 유형으로 `parallel-load`를 지정합니다.

1. (선택 사항) 파티션 이름의 배열을 `partitions` 값으로 지정하여 파티션을 포함합니다.

   그러면 지정된 각 파티션이 자체 스레드에 할당됩니다.
**중요**  
Oracle 엔드포인트의 경우, 병렬 로드를 위해 파티션과 하위 파티션을 선택할 때 파티션과 하위 파티션이 겹치지 않는지 확인하세요. 겹치는 파티션과 하위 파티션을 사용하여 데이터를 동시에 로드하면 항목이 중복되거나 프라이머리 키 중복 위반으로 인해 오류가 발생합니다.

1. (선택 사항) Oracle 엔드포인트의 경우 한해 하위 파티션 이름의 배열을 `subpartitions` 값으로 지정하여 하위 파티션을 포함합니다.

   그러면 지정된 각 하위 파티션이 자체 스레드에 할당됩니다.
**참고**  
파티션 또는 하위 파티션은 테이블 또는 뷰에 이미 정의된 경우에만 병렬 로드에 포함됩니다.

테이블 또는 뷰 세그먼트를 열 값의 범위로 지정할 수 있습니다. 이렇게 하려면 다음 열 특성을 알고 있어야 합니다.
+ 인덱싱된 열을 지정하면 성능이 크게 향상됩니다.
+ 최대 10개의 열을 지정할 수 있습니다.
+ 열을 사용하여 DOUBLE, FLOAT, BLOB, CLOB 및 NCLOB AWS DMS 데이터 형식으로 세그먼트 경계를 정의할 수 없습니다.
+ null 값의 레코드는 복제되지 않습니다.

**테이블, 뷰 또는 컬렉션 세그먼트를 열 값의 범위로 지정하려면**

1. `ranges` 유형으로 `parallel-load`를 지정합니다.

1. 열 이름의 배열을 `columns` 값으로 지정하여 테이블 또는 뷰 세그먼트 사이의 경계를 정의합니다. 테이블 또는 뷰 세그먼트 사이의 경계를 정의하려는 모든 열에 대해 이 작업을 수행합니다.

   열의 순서는 중요합니다. 다음 설명과 같이 각 경계를 정의하는 데 있어 첫 번째 열이 가장 중요하고 마지막 열은 가장 덜 중요합니다.

1. 모든 테이블 또는 뷰 세그먼트의 데이터 범위를 정의하려면 경계 배열의 값을 `boundaries`로 지정하세요. *경계 배열*은 열-값 배열의 배열입니다. 이 작업을 수행하려면 다음 단계를 수행하세요.

   1. 열-값 배열의 각 요소를 각 열에 맞는 값으로 지정합니다. *열-값 배열*은 정의하려는 각 테이블 또는 뷰 세그먼트의 상한을 나타냅니다. `columns` 배열에서 해당 열을 지정한 순서대로 각 열을 지정합니다.

      소스에서 지원하는 형식으로 DATE 열의 값을 입력합니다.

   1. 테이블 또는 뷰의 맨 아래에서 맨 위의 옆 세그먼트까지 각 세그먼트의 순서에 따라 각 열-값 배열을 상한으로 지정합니다. 지정한 맨 위 상한선 위에 행이 있으면 이 행은 테이블 또는 뷰의 맨 위 세그먼트를 완료합니다. 따라서 범위 기반 세그먼트의 수가 경계 배열의 세그먼트 경계 수보다 하나 더 많을 수 있습니다. 이러한 범위 기반 세그먼트는 각각 자체 스레드에 할당됩니다.

      테이블 또는 뷰의 모든 열에 데이터 범위를 정의하지 않더라도 null이 아닌 모든 데이터가 복제됩니다.

   예를 들어, 다음과 같이 열 COL1, COL2 및 COL3에 세 개의 열-값 배열을 정의한다고 가정합니다.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)

   가능한 총 4개 세그먼트에 세 개의 세그먼트 경계를 정의했습니다.

   각 세그먼트별로 복제할 행의 범위를 식별하기 위해 복제 인스턴스는 각각의 4개 세그먼트에서 이 3개 열에 검색을 적용합니다. 검색은 다음과 같습니다.  
**세그먼트 1**  
첫 번째 두 열의 값이 해당 **세그먼트 1** 상한값보다 작거나 같을 경우, 해당 모든 행을 복제합니다. 세 번째 열의 값이 **세그먼트 1** 상한 값 미만인 경우 모든 행을 복제합니다.  
**세그먼트 2**  
**세그먼트 1** 행을 제외한 모든 행을 복제하는 경우는 처음 두 열의 값이 해당 **세그먼트 2** 상한 값 이하입니다. 세 번째 열의 값이 **세그먼트 2** 상한 값 미만일 때 해당합니다.  
**세그먼트 3**  
**세그먼트 2** 행을 제외한 모든 행을 복제하는 경우는 처음 두 열의 값이 **해당 세그먼트 3** 상한 값 이하이고 세 번째 열의 값이 **세그먼트 3** 상한 값 미만일 때 해당합니다.  
**세그먼트 4**  
**세그먼트 1, 2 및 3** 행을 제외한 나머지 모든 행을 복제합니다.

   이 경우, 복제 인스턴스는 다음과 같이 `WHERE` 절을 작성하여 각 세그먼트를 로드합니다.  
**세그먼트 1**  
`((COL1 < 10) OR ((COL1 = 10) AND (COL2 < 30)) OR ((COL1 = 10) AND (COL2 = 30) AND (COL3 < 105)))`  
**세그먼트 2**  
`NOT ((COL1 < 10) OR ((COL1 = 10) AND (COL2 < 30)) OR ((COL1 = 10) AND (COL2 = 30) AND (COL3 < 105))) AND ((COL1 < 20) OR ((COL1 = 20) AND (COL2 < 20)) OR ((COL1 = 20) AND (COL2 = 20) AND (COL3 < 120)))`  
**세그먼트 3**  
`NOT ((COL1 < 20) OR ((COL1 = 20) AND (COL2 < 20)) OR ((COL1 = 20) AND (COL2 = 20) AND (COL3 < 120))) AND ((COL1 < 100) OR ((COL1 = 100) AND (COL2 < 12)) OR ((COL1 = 100) AND (COL2 = 12) AND (COL3 < 99)))`  
**세그먼트 4**  
`NOT ((COL1 < 100) OR ((COL1 = 100) AND (COL2 < 12)) OR ((COL1 = 100) AND (COL2 = 12) AND (COL3 < 99)))`

## 선택한 테이블 또는 뷰의 LOB 설정 지정
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.LOB"></a>

하나 이상의 `table-settings` 객체에 대해 `lob-settings` 옵션으로 `table-settings` 유형의 테이블 매핑 규칙을 생성하여 하나 이상의 테이블에 대한 작업 LOB 설정을 지정할 수 있습니다.

선택한 테이블 또는 뷰에 대한 LOB 설정 지정은 다음 소스 엔드포인트에서 지원됩니다.
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM DB2는 `mode` 및 `bulk-max-size` 설정에 따라 다음과 같이 설명됩니다.
+ SAP Adaptive Server Enterprise(ASE)는 다음과 같이 `mode` 및 `bulk-max-size` 설정에 따라 다릅니다.

선택한 테이블 또는 뷰에 대한 LOB 설정 지정은 다음 대상 엔드포인트에서 지원됩니다.
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ SAP ASE는 `mode` 및 `bulk-max-size` 설정에 따라 다음과 같이 설명됩니다.

**참고**  
프라이머리 키를 포함하는 테이블 및 뷰에서만 LOB 데이터 형식을 사용할 수 있습니다.

선택한 테이블 또는 뷰의 LOB 설정을 사용하려면 `table-settings` 옵션을 사용하여 `lob-settings` 유형의 테이블 매핑 규칙을 생성하세요. 이렇게 하면 `object-locator` 옵션으로 식별된 테이블 또는 뷰에 대한 LOB 처리가 지정됩니다. `table-settings` 규칙 내에서 다음 파라미터를 사용하여 `lob-settings` 객체를 지정할 수 있습니다.
+ `mode` – 다음과 같이 선택한 테이블 또는 뷰에 LOB 마이그레이션 처리 메커니즘을 지정합니다.
  + `limited` – 기본 모드인 제한적 LOB 모드는 가장 빠르고 효율적입니다. 모든 LOB의 크기가 작거나(100MB 이내) 대상 엔드포인트가 무제한 LOB 크기를 지원하지 않는 경우에만 이 모드를 사용하세요. 또한 `limited`를 사용하는 경우 모든 LOB는 `bulk-max-size`에 설정된 크기 내에 있어야 합니다.

    전체 로드 작업의 경우, 이 모드에서 복제 인스턴스는 기본 테이블 또는 뷰 스토리지의 일부로 다른 열 데이터 형식과 함께 모든 LOB를 인라인으로 마이그레이션합니다. 그러나 인스턴스는 `bulk-max-size` 값보다 큰 마이그레이션된 LOB를 모두 지정된 크기로 자릅니다. CDC(Change Data Capture) 로드 작업의 경우, 인스턴스는 표준 전체 LOB 모드(다음 참조)에서처럼 소스 테이블 조회를 사용하여 모든 LOB를 마이그레이션합니다.
**참고**  
뷰는 전체 로드 작업에 대해서만 마이그레이션할 수 있습니다.
  + `unlimited` – 전체 LOB 모드의 마이그레이션 메커니즘은 다음과 같이 `bulk-max-size`에 설정한 값에 따라 다릅니다.
    + **표준 ​​전체 LOB 모드** – `bulk-max-size`를 0으로 설정하면 복제 인스턴스가 표준 전체 LOB 모드를 사용하여 모든 LOB를 마이그레이션합니다. 이 모드에서는 크기에 관계없이 모든 LOB를 마이그레이션하려면 소스 테이블 또는 뷰를 조회해야 합니다. 이 경우, 일반적으로 제한적 LOB 모드보다 마이그레이션 속도가 훨씬 느립니다. 대부분 또는 모든 LOB가 큰 경우에만(1GB 이상) 이 모드를 사용하세요.
    + **조합 전체 LOB 모드** – `bulk-max-size`를 0이 아닌 값으로 설정하면 이 전체 LOB 모드는 제한적 LOB 모드와 표준 전체 LOB 모드를 조합하여 사용합니다. 전체 로드 작업에서 LOB 크기가 `bulk-max-size` 값 이내에 있는 경우, 인스턴스는 제한적 LOB 모드에서처럼 LOB를 인라인으로 마이그레이션합니다. LOB 크기가 이 값보다 큰 경우, 인스턴스는 표준 전체 LOB 모드에서와 같이 소스 테이블 또는 뷰 조회를 사용하여 LOB를 마이그레이션합니다. CDC(Change Data Capture) 로드 작업의 경우, 인스턴스는 표준 전체 LOB 모드(다음 참조)에서처럼 소스 테이블 조회를 사용하여 모든 LOB를 마이그레이션합니다. LOB 크기와는 관계없습니다.
**참고**  
뷰는 전체 로드 작업에 대해서만 마이그레이션할 수 있습니다.

      이 모드의 마이그레이션 속도는 빠른 제한적 LOB 모드와 느린 표준 전체 LOB 모드 사이에서 절충한 수준이 됩니다. 작고 큰 LOB가 혼합되어 있지만 대부분의 LOB가 작은 경우에만 이 모드를 사용하세요.

      이 조합된 전체 LOB 모드는 다음 엔드포인트에서만 사용 가능합니다.
      + IBM DB2 소스로만 사용 
      + SAP ASE 소스 또는 대상으로 사용

    `unlimited` 모드를 지정하는 메커니즘에 관계없이, 인스턴스는 모든 LOB를 자르지 않고 온전히 마이그레이션합니다.
  + `none` – 복제 인스턴스는 작업 LOB 설정을 사용하여 선택한 테이블 또는 뷰의 LOB를 마이그레이션합니다. 이 옵션을 사용하면 선택한 테이블 또는 뷰의 LOB 설정 유무와 관계없이 마이그레이션 결과를 쉽게 비교할 수 있습니다.

  복제에 포함된 LOB가 있는 테이블 또는 뷰를 지정한 경우 `limited` LOB 모드 사용 시 `BatchApplyEnabled` 작업 설정을 `true`로만 설정할 수 있습니다.

  경우에 따라 `BatchApplyEnabled`를 `true`로, `BatchApplyPreserveTransaction`을 `false`로 설정해야 할 수 있습니다. 이러한 경우, 테이블 또는 뷰에 LOB가 있고 소스 및 대상 엔드포인트가 Oracle이면 인스턴스가 `BatchApplyPreserveTransaction`을 `true`로 설정합니다.
+ `bulk-max-size` – 이전 항목에서 설명한 대로, `mode`에 따라 이 값을 0 또는 0이 아닌 값(킬로바이트)으로 설정합니다. `limited` 모드에서는 이 파라미터에 0이 아닌 값을 설정해야 합니다.

  인스턴스는 LOB를 이진 형식으로 변환합니다. 따라서 복제해야 하는 가장 큰 LOB를 지정하려면 크기에 3을 곱하세요. 예를 들어, 가장 큰 LOB가 2MB라면 `bulk-max-size`를 6,000(6MB)으로 설정합니다.

## 테이블 설정 예제
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Examples"></a>

다음은 테이블 설정 사용법을 보여주는 몇 가지 예제입니다.

**Example 파티션별로 세그먼트화된 테이블 로드**  
다음 예제는 모든 파티션을 기반으로 소스의 `SALES` 테이블을 동시에 로드하기 때문에 보다 효율적입니다.  

```
{
   "rules": [{
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "HR",
                "table-name": "SALES"
            },
            "parallel-load": {
                "type": "partitions-auto"
            }
        }
     ]
}
```

**Example 하위 파티션별로 세그먼트화된 테이블 로드**  
다음 예제는 모든 하위 파티션을 기반으로 Oracle 소스의 `SALES` 테이블을 동시에 로드하기 때문에 보다 효율적입니다.  

```
{
   "rules": [{
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "HR",
                "table-name": "SALES"
            },
            "parallel-load": {
                "type": "subpartitions-auto"
            }
        }
     ]
}
```

**Example 파티션 목록별로 세그먼트화된 테이블 로드**  
다음 예제는 특정 파티션 목록별로 소스의 `SALES` 테이블을 동시에 로드합니다. 여기서 지정된 파티션은 알파벳의 일부로 시작하는 값을 따라 이름이 지정됩니다(예: `ABCD`, `EFGH` 등).  

```
{
    "rules": [{
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "HR",
                "table-name": "SALES"
            },
            "parallel-load": {
                "type": "partitions-list",
                "partitions": [
                    "ABCD",
                    "EFGH",
                    "IJKL",
                    "MNOP",
                    "QRST",
                    "UVWXYZ"
                ]
            }
        }
    ]
}
```

**Example 선택한 파티션 및 하위 파티션 목록으로 세그먼트화된 Oracle 테이블 로드**  
다음 예제는 선택한 파티션 및 하위 파티션 목록별로 Oracle 소스의 `SALES` 테이블을 동시에 로드합니다. 여기서 지정된 파티션은 알파벳의 일부로 시작하는 값을 따라 이름이 지정됩니다(예: `ABCD`, `EFGH` 등). 지정된 하위 파티션의 이름은 숫자로 시작하는 값을 따라 지정됩니다(예: `01234` 및 `56789`).  

```
{
    "rules": [{
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "HR",
                "table-name": "SALES"
            },
            "parallel-load": {
                "type": "partitions-list",
                "partitions": [
                    "ABCD",
                    "EFGH",
                    "IJKL",
                    "MNOP",
                    "QRST",
                    "UVWXYZ"
                ],
                "subpartitions": [
                    "01234",
                    "56789"
                ]
            }
        }
    ]
}
```

**Example 열 값 범위별로 세그먼트화된 테이블 로드**  
다음 예에서는 `SALES_NO` 및 `REGION` 열 값의 범위로 지정된 세그먼트별로 소스의 `SALES` 테이블을 동시에 로드합니다.  

```
{
    "rules": [{
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "HR",
                "table-name": "SALES"
            },
            "parallel-load": {
                "type": "ranges",
                "columns": [
                    "SALES_NO",
                    "REGION"
                ],
                "boundaries": [
                    [
                        "1000",
                        "NORTH"
                    ],
                    [
                        "3000",
                        "WEST"
                    ]
                ]
            }
        }
    ]
}
```
여기에서는 이름이 `SALES_NO` 및 `REGION`인 세그먼트 범위에 두 개의 열이 지정됩니다. 두 경계는 두 열 값 집합(`["1000","NORTH"]` 및 `["3000","WEST"]`)으로 지정됩니다.  
따라서 이 두 경계는 동시에 로드할 다음 세 개 테이블 세그먼트를 식별합니다.    
세그먼트 1  
`SALES_NO`가 1,000 이하이고 `REGION`이 ‘NORTH’보다 작은 행. 즉, EAST 리전에서 1,000 이하의 매출 수치입니다.  
세그먼트 2  
**세그먼트 1** 이외의 행이 3,000개 `SALES_NO` 이하이고 ‘WEST’ `REGION` 미만입니다. 즉, NORTH 및 SOUTH 리전에서 1000보다 크고 3,000 이하인 매출 수치입니다.  
세그먼트 3  
**세그먼트 1** 및 **세그먼트 2** 이외의 나머지 모든 행. 즉, ‘WEST’ 리전에서 3,000을 초과하는 매출 수치입니다.

**Example 두 개의 테이블 로드: 하나는 범위별로 세그먼트화, 다른 하나는 파티션별로 세그먼트화됨**  
다음 예제에서는 식별하는 세그먼트 경계로 `SALES` 테이블을 동시에 로드합니다. 또한 이전 예제와 같이 모든 파티션으로 `ORDERS` 테이블을 동시에 로드합니다.  

```
{
    "rules": [{
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "HR",
                "table-name": "SALES"
            },
            "parallel-load": {
                "type": "ranges",
                "columns": [
                    "SALES_NO",
                    "REGION"
                ],
                "boundaries": [
                    [
                        "1000",
                        "NORTH"
                    ],
                    [
                        "3000",
                        "WEST"
                    ]
                ]
            }
        },
        {
            "rule-type": "table-settings",
            "rule-id": "3",
            "rule-name": "3",
            "object-locator": {
                "schema-name": "HR",
                "table-name": "ORDERS"
            },
            "parallel-load": {
                "type": "partitions-auto" 
            }
        }
    ]
}
```

**Example 작업 LOB 설정을 사용하여 LOB 포함 테이블 로드**  
다음 예제는 작업 LOB 설정을 사용하여 모든 LOB를 포함하여 소스의 `ITEMS` 테이블을 로드합니다. 100MB의 `bulk-max-size` 설정은 무시되며 `limited` 또는 `unlimited` 모드로 신속하게 재설정하는 경우에만 유지됩니다.  

```
{
   "rules": [{
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "INV",
                "table-name": "ITEMS"
            },
            "lob-settings": {
                "mode": "none",
                "bulk-max-size": "100000"
            }
        }
     ]
}
```

**Example 제한적 LOB 모드를 사용하여 LOB 포함 테이블 로드**  
다음 예제는 제한적 LOB 모드(기본값)를 사용하여 소스의 LOB를 포함하는 `ITEMS` 테이블을 로드하며, 잘리지 않는 최대 크기로 100MB를 지원합니다. 이 크기보다 큰 LOB는 100MB로 잘립니다. 모든 LOB는 다른 모든 열 데이터 형식과 인라인으로 로드됩니다.  

```
{
   "rules": [{
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "INV",
                "table-name": "ITEMS"
            },
            "lob-settings": {
                "bulk-max-size": "100000"
            }
        }
     ]
}
```

**Example 표준 전체 LOB 모드를 사용하여 LOB 포함 테이블 로드**  
다음 예제는 표준 전체 LOB 모드를 사용하여 절단하지 않은 모든 LOB를 포함하여 소스의 `ITEMS` 테이블을 로드합니다. 크기에 관계없이 모든 LOB는 소스 테이블의 각 LOB 조회를 사용하여 다른 데이터 형식과 별도로 로드됩니다.  

```
{
   "rules": [{
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "INV",
                "table-name": "ITEMS"
            },
            "lob-settings": {
                "mode": "unlimited",
                "bulk-max-size": "0"
            }
        }
     ]
}
```

**Example 조합 전체 LOB 모드를 사용하여 LOB 포함 테이블 로드**  
다음 예제는 조합 전체 LOB 모드를 사용하여 절단하지 않은 모든 LOB를 포함하여 소스의 `ITEMS` 테이블을 로드합니다. 제한적 LOB 모드에서와 같이, 크기 100MB 이내의 모든 LOB는 다른 데이터 형식과 함께 인라인으로 로드됩니다. 크기가 100MB를 초과하는 모든 LOB는 다른 데이터 형식과 별도로 로드됩니다. 이 별도의 로드는 표준 전체 LOB 모드에서와 같이 소스 테이블의 각 LOB에 대해 조회를 사용합니다.  

```
{
   "rules": [{
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "%",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "INV",
                "table-name": "ITEMS"
            },
            "lob-settings": {
                "mode": "unlimited",
                "bulk-max-size": "100000"
            }
        }
     ]
}
```

# 데이터 마스킹을 사용하여 민감한 정보 숨기기
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking"></a>

마이그레이션 중인 테이블의 하나 이상의 열에 저장된 민감한 데이터를 숨기려면 데이터 마스킹 변환 규칙 작업을 활용할 수 있습니다. 버전 3.5.4부터를 AWS DMS 사용하면 테이블 매핑에서 데이터 마스킹 변환 규칙 작업을 사용할 수 있으므로 마이그레이션 프로세스 중에 하나 이상의 열의 내용을 변경할 수 있습니다.는 수정된 데이터를 대상 테이블에 AWS DMS 로드합니다.

AWS Database Migration Service 는 데이터 마스킹 변환 규칙 작업을 위한 세 가지 옵션을 제공합니다.
+ 데이터 마스킹: 숫자 마스킹
+ 데이터 마스킹: 숫자 임의화
+ 데이터 마스킹: 해싱 마스크

이러한 데이터 마스킹 변환 규칙 작업은 다른 변환 규칙과 마찬가지로 복제 작업의 테이블 매핑에서 구성할 수 있습니다. 규칙 대상은 열 수준으로 설정해야 합니다.

## 마스킹 문자를 사용하여 열 데이터의 번호 마스킹
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.Numbers"></a>

"데이터 마스킹: 숫자 마스킹" 변환 규칙 작업을 사용하면 숫자를 지정한 단일 ASCII 인쇄 가능 문자(빈 문자 또는 공백 문자 제외)로 대체하여 하나 이상의 열에서 숫자 데이터를 마스킹할 수 있습니다.

다음은 `customer_master` 테이블에 있는 `cust_passport_no` 열의 모든 숫자를 `'#'` 마스킹 문자로 마스킹하고 마스킹된 데이터를 대상 테이블에 로드하는 예제입니다.

```
                {
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "cust_schema",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "transformation",
            "rule-id": "2",
            "rule-name": "2",
            "rule-target": "column",
            "object-locator": {
                "schema-name": "cust_schema",
                "table-name": "customer_master",
                "column-name": "cust_passport_no"
            },
            "rule-action": "data-masking-digits-mask",
            "value": "#"
        }
    ]
}
```

예를 들어 소스 테이블의 열`cust_passport_no`에 "C6BGJ566669K" 레코드가 포함된 경우 AWS DMS 작업은이 데이터를 대상 테이블에 로 기록합니다`"C#BGJ######K"`.

## 열의 숫자를 난수로 바꾸기
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.Random"></a>

변환 규칙 "데이터 마스킹: 숫자 임의화"를 사용하면 하나 이상의 열에 있는 각 숫자 숫자를 난수로 바꿀 수 있습니다. 다음 예제에서는 소스 테이블 `cust_passport_no` 열의 모든 숫자를 난수`customer_master`로 AWS DMS 바꾸고 수정된 데이터를 대상 테이블에 씁니다.

```
            {
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "cust_schema",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "transformation",
            "rule-id": "2",
            "rule-name": "2",
            "rule-target": "column",
            "object-locator": {
                "schema-name": "cust_schema",
                "table-name": "customer_master",
                "column-name": "cust_passport_no"
            },
            "rule-action": "data-masking-digits-randomize"
        }
    ]
}
```

예를 들어 AWS DMS 작업은 소스 테이블의 `cust_passport_no` 열`"C6BGJ566669K"`에 있는 값을 로 변환`"C1BGJ842170K"`하고 대상 데이터베이스에 씁니다.

## 열 데이터를 해시 값으로 바꾸기
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.Hash"></a>

변환 규칙 "데이터 마스킹: 해싱 마스크"를 사용하면 열 데이터를 `SHA256` 알고리즘을 사용하여 생성된 해시로 바꿀 수 있습니다. 해시 길이는 항상 64자이므로 대상 테이블 열 길이는 최소 64자여야 합니다. 또는 열에 `change-data-type` 변환 규칙 작업을 추가하여 대상 테이블의 열 너비를 늘릴 수 있습니다.

다음 예제에서는 소스 테이블의 `cust_passport_no` 열에 있는 데이터에 대해 64자 길이의 해시 값을 생성하고 열 길이를 늘린 후 변환된 데이터를 대상 테이블에 `customer_master` 로드합니다.

```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "customer_master",
"column-name": "cust_passport_no"
},
"rule-action": "change-data-type",
"data-type": {
"type": "string",
"length": "100",
"scale": ""
}
},
{
"rule-type": "transformation",
"rule-id": "3",
"rule-name": "3",
"rule-target": "column",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "customer_master",
"column-name": "cust_passport_no"
},
"rule-action": "data-masking-hash-mask"
}
]
}
```

예를 들어 소스 테이블`cust_passport_no`의 열에 값이 포함된 경우 `“C6BGJ566669K”` AWS DMS 작업은 대상 테이블에 해시`“7CB06784764C9030CCC41E25C15339FEB293FFE9B329A72B5FED564E99900C75”`를 씁니다.

## 제한 사항
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.Limitations"></a>
+ 각 데이터 마스킹 변환 규칙 옵션은 특정 AWS DMS 데이터 유형에 대해서만 지원됩니다.
  + 데이터 마스킹: 데이터 형식의 열인 `WSTRING` 및 `STRING`에 대해 숫자 마스킹이 지원됩니다.
  + 데이터 마스킹: Digits Randomize는 서명되지 않은 `WSTRING, STRING; NUMERIC, INT1, INT2, INT4, and INT8 ` 데이터 형식의 열에 대해 지원됩니다.
  + 데이터 마스킹: 해싱 마스크는 `WSTRING` 및 `STRING` 데이터 유형의 열에 대해 지원됩니다.

  소스 엔진의 AWS DMS 데이터 형식에 데이터 형식을 매핑하는 방법에 대해 자세히 알아보려면 소스 엔진과 데이터 형식의 AWS DMS 데이터 형식 매핑을 참조하세요. [Oracle용 소스 데이터 형식](CHAP_Source.Oracle.md#CHAP_Source.Oracle.DataTypes), [SQL Server용 소스 데이터 형식](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.DataTypes), [PostgreSQL용 소스 데이터 형식](CHAP_Source.PostgreSQL.md#CHAP_Source-PostgreSQL-DataTypes)및 [MySQL용 소스 데이터 형식](CHAP_Source.MySQL.md#CHAP_Source.MySQL.DataTypes)에 대한 소스 데이터 유형을 참조하세요.
+ 데이터 유형이 호환되지 않는 열에 데이터 마스킹 규칙 작업을 사용하면 DMS 작업에서 오류가 발생합니다. 오류 처리 동작을 지정하려면 DMS 작업 설정의 DataMaskingErrorPolicy를 참조하세요. `DataMaskingErrorPolicy`에 대한 자세한 내용은 [오류 처리 작업 설정](CHAP_Tasks.CustomizingTasks.TaskSettings.ErrorHandling.md) 섹션을 참조하세요.
+ 소스 열 유형이 사용하려는 마스킹 옵션에 대해 지원되지 않는 경우 change-data-type 변환 규칙 작업을 추가하여 열의 데이터 유형을 호환되는 유형으로 변경할 수 있습니다. 데이터 형식이 마스킹 전에 변경되도록 `change-data-type` 변환의 `rule-id`는 마스킹 변환의 규칙 ID보다 작은 숫자여야 합니다.
+ 생성된 해시 값이 고유하고 일관되므로 데이터 마스킹 사용: 프라이머리 키/고유 키/외부 키 열을 마스킹하기 위한 해싱 마스크 작업입니다. 다른 두 마스킹 옵션은 고유성을 보장할 수 없습니다.
+ 데이터 마스킹: 숫자 마스킹 및 데이터 마스킹: 숫자 임의화는 열 데이터의 숫자에만 영향을 미치고 데이터 길이에는 영향을 미치지 않지만, 데이터 마스킹: 해싱 마스크는 전체 열을 수정하고 데이터 길이는 64자로 변경됩니다. 따라서 그에 따라 생성할 대상 테이블 또는 마스킹되는 열에 대해 change-data-type 변환 규칙을 추가해야 합니다.
+ 데이터 마스킹 변환 규칙 작업이 지정된 열은 AWS DMS의 데이터 검증에서 제외됩니다. 프라이머리 키/고유 키 열이 마스킹된 경우 이 테이블에 대한 데이터 검증이 실행되지 않습니다. 이러한 테이블의 검증 상태는 `No Primary key`와 같습니다.