Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan pemetaan tabel untuk menentukan pengaturan tugas
Tabel pemetaan menggunakan beberapa jenis aturan untuk menentukan sumber data, skema sumber, data, dan setiap transformasi yang harus terjadi selama tugas. Anda dapat menggunakan pemetaan tabel untuk menentukan tabel individu dalam database untuk bermigrasi dan skema yang digunakan untuk migrasi.
Ketika bekerja dengan pemetaan tabel, Anda dapat menggunakan filter untuk menentukan data yang ingin direplikasi dari kolom tabel. Selain itu, Anda dapat menggunakan transformasi untuk memodifikasi dipilih skema, tabel, atau tampilan sebelum mereka ditulis ke database target.
**Topics**
+ [
# Menentukan pemilihan tabel dan transformasi aturan dari konsol
](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md)
+ [
# Menentukan pemilihan tabel dan transformasi aturan menggunakan JSON
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.md)
+ [
# Aturan seleksi dan tindakan
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md)
+ [
# Wildcard dalam pemetaan tabel
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md)
+ [
# Aturan dan tindakan transformasi
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)
+ [
# Menggunakan ekspresi aturan transformasi untuk menentukan isi kolom
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md)
+ [
# Tabel dan koleksi pengaturan aturan dan operasi
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md)
+ [
# Menggunakan masking data untuk menyembunyikan informasi sensitif
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.md)
**catatan**
Ketika bekerja dengan pemetaan meja untuk endpoint sumber MongoDB, Anda dapat menggunakan filter untuk menentukan data yang ingin direplikasi, dan menentukan nama database di tempat`schema_name`. Atau, Anda dapat menggunakan default`"%"`.
# Menentukan pemilihan tabel dan transformasi aturan dari konsol
Anda dapat menggunakan Konsol Manajemen AWS untuk melakukan pemetaan tabel, termasuk menentukan pemilihan tabel dan transformasi. Pada konsol, gunakan**Di mana**bagian untuk menentukan skema, tabel, dan tindakan (termasuk atau mengecualikan). Gunakan**Filter**bagian untuk menentukan nama kolom dalam tabel dan kondisi yang ingin Anda terapkan untuk tugas replikasi. Bersama-sama, kedua tindakan ini membuat aturan seleksi.
Anda dapat menyertakan transformasi dalam pemetaan tabel setelah Anda telah ditentukan setidaknya satu aturan pilihan. Anda dapat menggunakan transformasi untuk mengubah nama skema atau tabel, menambahkan awalan atau akhiran untuk skema atau tabel, atau menghapus kolom tabel.
**catatan**
AWS DMS tidak mendukung lebih dari satu aturan transformasi per tingkat skema, tingkat tabel, atau tingkat kolom.
Prosedur berikut menunjukkan cara mengatur aturan seleksi, berdasarkan tabel yang disebut**Customers**dalam skema yang disebut**EntertainmentAgencySample**.
**Untuk menentukan pilihan tabel, kriteria filter, dan transformasi menggunakan konsol**
1. Masuk ke Konsol Manajemen AWS dan buka AWS DMS konsol di [https://console.aws.amazon.com/dms/v2/](https://console.aws.amazon.com/dms/v2/).
Jika Anda masuk sebagai pengguna IAM, pastikan Anda memiliki izin yang tepat untuk mengakses AWS DMS. Untuk informasi lebih lanjut tentang izin yang diperlukan, lihat [Izin IAM diperlukan untuk menggunakan AWS DMS](security-iam.md#CHAP_Security.IAMPermissions).
1. Pada halaman **Dasbor**, pilih **tugas migrasi database**.
1. Pilih**Buat tugas**.
1. **Di bagian **Konfigurasi tugas**, masukkan informasi tugas, termasuk **pengidentifikasi tugas**, **contoh replikasi**, **titik akhir basis data sumber, titik akhir basis data** **target, dan tipe Migrasi**.**
![\[Skema dan pemilihan meja\]](http://docs.aws.amazon.com/id_id/dms/latest/userguide/images/datarep-create-task-20.png)
1. Di bagian **Pemetaan tabel**, masukkan nama skema dan nama tabel. Anda dapat menggunakan “%” sebagai nilai wildcard saat menentukan nama skema atau nama tabel. Untuk informasi tentang wildcard lain yang dapat Anda gunakan, lihat[Wildcard dalam pemetaan tabel](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md). Tentukan tindakan yang akan diambil, untuk menyertakan atau mengecualikan data yang didefinisikan oleh filter.
![\[Skema dan pemilihan meja\]](http://docs.aws.amazon.com/id_id/dms/latest/userguide/images/datarep-Tasks-selecttransfrm.png)
1. Tentukan informasi filter menggunakan**Tambahkan filter kolom**dan**Tambahkan kondisi**Tautan.
1. Pilih**Tambahkan filter kolom**untuk menentukan kolom dan kondisi.
1. Pilih**Tambahkan kondisi**untuk menambahkan kondisi tambahan.
Contoh berikut menunjukkan filter untuk**Customers**tabel yang mencakup**AgencyIDs**antara**01**dan**85**.
![\[Skema dan pemilihan meja\]](http://docs.aws.amazon.com/id_id/dms/latest/userguide/images/datarep-Tasks-filter.png)
1. Ketika Anda telah membuat pilihan yang Anda inginkan, pilih **Tambahkan aturan pilihan baru**.
1. Setelah Anda telah membuat setidaknya satu aturan pilihan, Anda dapat menambahkan transformasi untuk tugas. Pilih**tambahkan aturan transformasi**.
![\[Aturan transformasi\]](http://docs.aws.amazon.com/id_id/dms/latest/userguide/images/datarep-Tasks-transform1.png)
1. Pilih target yang ingin Anda ubah, dan masukkan informasi tambahan yang diminta. Contoh berikut menunjukkan transformasi yang menghapus**AgencyStatus**kolom dari**Customer**Tabel.
![\[Aturan transformasi\]](http://docs.aws.amazon.com/id_id/dms/latest/userguide/images/datarep-Tasks-transform2.png)
1. Pilih**Tambahkan aturan transformasi**.
1. Pilih **Buat tugas**.
**catatan**
AWS DMS tidak mendukung lebih dari satu aturan transformasi per tingkat skema, tingkat tabel, atau tingkat kolom.
# Menentukan pemilihan tabel dan transformasi aturan menggunakan JSON
Untuk menentukan pemetaan tabel yang ingin Anda terapkan selama migrasi, Anda dapat membuat file JSON. Jika Anda membuat tugas migrasi menggunakan konsol, Anda dapat menelusuri file JSON ini atau memasukkan JSON langsung ke kotak pemetaan tabel. Jika Anda menggunakan CLI atau API untuk melakukan migrasi, Anda dapat menentukan file ini menggunakan parameter `TableMappings` dari operasi API `CreateReplicationTask` atau `ModifyReplicationTask`.
AWS DMS hanya dapat memproses pemetaan tabel file JSON hingga ukuran 2 MB. Kami menyarankan Anda menjaga aturan pemetaan ukuran file JSON di bawah batas 2 MB saat bekerja dengan tugas DMS. Ini mencegah kesalahan tak terduga selama pembuatan atau modifikasi tugas. Ketika file aturan pemetaan melebihi batas 2 MB, kami sarankan Anda membagi tabel di beberapa tugas untuk mengurangi ukuran file aturan pemetaan sehingga tetap di bawah batas ini.
Anda dapat menentukan apa tabel, pandangan, dan skema Anda ingin bekerja dengan. Anda juga dapat melakukan tabel, tampilan, dan skema transformasi dan menentukan pengaturan untuk bagaimana AWS DMS beban tabel individu dan pandangan. Anda membuat aturan pemetaan tabel untuk opsi ini menggunakan jenis aturan berikut:
+ `selection`rules - Mengidentifikasi jenis dan nama tabel sumber, pandangan, dan skema untuk memuat. Untuk informasi selengkapnya, lihat [Aturan seleksi dan tindakan](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md).
+ `transformation`rules - Tentukan perubahan tertentu atau penambahan tabel sumber tertentu dan skema pada sumber sebelum mereka dimuat pada target. Untuk informasi selengkapnya, lihat [Aturan dan tindakan transformasi](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md).
Juga, untuk menentukan isi kolom baru dan yang sudah ada, Anda dapat menggunakan ekspresi dalam aturan transformasi. Untuk informasi selengkapnya, lihat [Menggunakan ekspresi aturan transformasi untuk menentukan isi kolom](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md).
+ `table-settings`rules - Tentukan bagaimana tugas DMS memuat data untuk tabel individu. Untuk informasi selengkapnya, lihat [Tabel dan koleksi pengaturan aturan dan operasi](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md).
**catatan**
Untuk target Amazon S3, Anda juga dapat menandai objek S3 dipetakan ke tabel yang dipilih dan skema menggunakan`post-processing`aturan jenis dan`add-tag`Tindakan aturan. Untuk informasi selengkapnya, lihat [Penandaan objek Amazon S3](CHAP_Target.S3.md#CHAP_Target.S3.Tagging).
Untuk target berikut, Anda dapat menentukan bagaimana dan di mana dipilih skema dan tabel dimigrasi ke target menggunakan`object-mapping`Jenis aturan:
Amazon DynamoDB — Untuk informasi lebih lanjut, lihat[Menggunakan pemetaan objek untuk migrasi data ke DynamoDB](CHAP_Target.DynamoDB.md#CHAP_Target.DynamoDB.ObjectMapping).
Amazon Kinesis — Untuk informasi lebih lanjut, lihat[Menggunakan pemetaan objek untuk memigrasi data ke Kinesis data stream](CHAP_Target.Kinesis.md#CHAP_Target.Kinesis.ObjectMapping).
Apache Kafka - Untuk informasi lebih lanjut, lihat[Menggunakan pemetaan objek untuk bermigrasi data ke topik Kafka](CHAP_Target.Kafka.md#CHAP_Target.Kafka.ObjectMapping).
# Aturan seleksi dan tindakan
Menggunakan pemetaan tabel, Anda dapat menentukan apa tabel, pandangan, dan skema Anda ingin bekerja dengan dengan menggunakan aturan seleksi dan tindakan. Untuk aturan pemetaan tabel yang menggunakan jenis aturan seleksi, Anda dapat menerapkan nilai berikut.
**Awas**
Jangan menyertakan data sensitif apa pun dalam aturan ini.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.html)
**Example Memigrasi semua tabel dalam skema**
Contoh berikut bermigrasi semua tabel dari skema bernama`Test`di sumber Anda ke titik akhir target Anda.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
}
]
}
```
**Example Memigrasi beberapa tabel dalam skema**
Contoh berikut bermigrasi semua tabel kecuali yang dimulai dengan`DMS`dari sebuah skema bernama`Test`di sumber Anda ke titik akhir target Anda.
```
{
"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 Memigrasi tabel tunggal tertentu dalam skema tunggal**
Contoh berikut memigrasikan`Customer`Tabel dari`NewCust`skema di sumber Anda ke titik akhir target Anda.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "NewCust",
"table-name": "Customer"
},
"rule-action": "explicit"
}
]
}
```
Anda dapat secara eksplisit memilih pada beberapa tabel dan skema dengan menentukan beberapa aturan seleksi.
**Example Memigrasi tabel dalam urutan set**
Tabel dan tampilan dimigrasikan sesuai dengan nilai urutan pemuatannya, dengan nilai yang lebih tinggi menerima prioritas dalam urutan migrasi. Contoh berikut memigrasikan dua tabel, `loadfirst` dengan nilai prioritas 2 dan `loadsecond` dengan nilai prioritas 1, tugas migrasi pertama-tama akan memproses `loadfirst` tabel sebelum melanjutkan ke tabel`loadsecond`. Mekanisme prioritas ini memastikan bahwa dependensi antara objek database dihormati selama proses migrasi.
```
{
"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"
}
]
}
```
**catatan**
`load-order`berlaku untuk inisialisasi tabel. Beban tabel berturut-turut tidak akan menunggu beban tabel sebelumnya selesai jika `MaxFullLoadSubTasks` lebih besar dari 1.
**Example Memigrasi beberapa tampilan dalam skema**
Contoh berikut bermigrasi beberapa pandangan dari skema bernama`Test`di sumber Anda untuk tabel setara dalam target Anda.
```
{
"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 Memigrasi semua tabel dan tampilan dalam skema**
Contoh berikut bermigrasi semua tabel dan pandangan dari skema bernama`report`di sumber Anda untuk tabel setara dalam target Anda.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "3",
"rule-name": "3",
"object-locator": {
"schema-name": "report",
"table-name": "%",
"table-type": "all"
},
"rule-action": "include"
}
]
}
```
# Wildcard dalam pemetaan tabel
Bagian ini menjelaskan wildcard yang dapat Anda gunakan saat menentukan skema dan nama tabel untuk pemetaan tabel.
| Wildcard | Cocok |
| --- |--- |
| % | Nol atau lebih karakter |
| \$1 | Satu karakter |
| [\$1] | Karakter garis bawah literal |
| [ab] | Satu set karakter. Misalnya, [ab] cocok dengan 'a' atau 'b'. |
| [a-d] | Berbagai karakter. Misalnya, [a-d] cocok dengan 'a', 'b', 'c', atau 'd'. |
Untuk sumber Oracle dan titik akhir target, Anda dapat menggunakan atribut koneksi `escapeCharacter` tambahan untuk menentukan karakter escape. Karakter escape memungkinkan Anda untuk menggunakan karakter wildcard tertentu dalam ekspresi seolah-olah itu tidak liar. Misalnya, `escapeCharacter=#` memungkinkan Anda untuk menggunakan '\$1' untuk membuat karakter wildcard bertindak sebagai karakter biasa dalam ekspresi seperti dalam kode contoh ini.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "542485267",
"rule-name": "542485267",
"object-locator": { "schema-name": "ROOT", "table-name": "TEST#_T%" },
"rule-action": "include",
"filters": []
}
]
}
```
Di sini, karakter escape '\$1' membuat karakter wildcard '\$1' bertindak sebagai karakter normal. AWS DMS memilih tabel dalam skema bernama`ROOT`, di mana setiap tabel memiliki nama dengan `TEST_T` sebagai awalan.
# Aturan dan tindakan transformasi
Anda menggunakan tindakan transformasi untuk menentukan setiap transformasi Anda ingin menerapkan skema yang dipilih, tabel, atau tampilan. Aturan transformasi adalah opsional.
## Batasan
+ Anda tidak dapat menerapkan lebih dari satu tindakan aturan transformasi terhadap objek yang sama (skema, tabel, kolom, table-tablespace, atau index-tablespace). Anda dapat menerapkan beberapa tindakan aturan transformasi pada tingkat apa pun selama setiap tindakan transformasi diterapkan terhadap objek yang berbeda. Namun, pembatasan ini tidak berlaku saat menggunakan aturan transformasi masking data di mana Anda dapat memiliki transformasi lain seperti `ADD-COLUMN` atau `CHANGE-DATA-TYPE` untuk kolom yang sama.
+ Nama tabel dan nama kolom dalam aturan transformasi peka huruf besar/kecil. Misalnya, Anda harus memberikan nama tabel dan nama kolom untuk database Oracle atau Db2 dalam huruf besar.
+ Transformasi tidak didukung untuk nama kolom dengan Right-to-Left bahasa.
+ Transformasi tidak dapat dilakukan pada kolom yang berisi karakter khusus (misalnya \$1,\$1,/, -) dalam namanya.
+ Satu-satunya transformasi yang didukung untuk kolom yang dipetakan ke tipe BLOB/CLOB data adalah dengan menjatuhkan kolom pada target.
+ AWS DMS tidak mendukung replikasi dua tabel sumber ke satu tabel target. AWS DMS mereplikasi catatan dari tabel ke tabel, dan dari kolom ke kolom, sesuai dengan aturan transformasi tugas replikasi. Nama objek harus unik untuk mencegah tumpang tindih.
Misalnya, tabel sumber memiliki kolom bernama `ID` dan tabel target yang sesuai memiliki kolom yang sudah ada sebelumnya yang disebut`id`. Jika aturan menggunakan `ADD-COLUMN` pernyataan untuk menambahkan kolom baru yang disebut`id`, dan SQLite pernyataan untuk mengisi kolom dengan nilai kustom, ini akan menciptakan duplikat, objek ambigu bernama `id` dan tidak didukung.
+ Saat membuat aturan transformasi, sebaiknya gunakan `data-type` parameter hanya jika aturan pemilihan menentukan beberapa kolom, misalnya, saat Anda `column-name` menyetelnya`%`. Kami tidak menyarankan menggunakan `data-type` untuk memilih satu kolom.
+ AWS DMS tidak mendukung aturan transformasi di mana objek sumber dan target (tabel) berada pada database/skema yang sama. Menggunakan tabel yang sama sebagai sumber dan target dalam aturan transformasi dapat menyebabkan hasil yang tidak terduga dan berpotensi berbahaya, termasuk namun tidak terbatas pada perubahan yang tidak diinginkan pada data tabel, modifikasi struktur tabel atau bahkan tabel yang dijatuhkan.
## Nilai
Untuk aturan pemetaan tabel yang menggunakan jenis aturan transformasi, Anda dapat menerapkan nilai berikut.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.html)
## Contoh
**Example Ubah Nama Skema**
Contoh berikut mengganti nama skema dari`Test`di sumber Anda untuk`Test1`dalam target Anda.
```
{
"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 Ubah Nama Tabel**
Contoh berikut mengganti nama tabel dari`Actor`di sumber Anda untuk`Actor1`dalam target Anda.
```
{
"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 Ubah Nama Kolom**
Contoh berikut mengganti nama kolom dalam tabel`Actor`dari`first_name`di sumber Anda untuk`fname`dalam target Anda.
```
{
"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 Mengubah nama tablespace tabel Oracle**
Contoh berikut mengganti nama tablespace tabel bernama`SetSpace`untuk sebuah tabel bernama`Actor`di sumber Oracle Anda untuk`SceneTblSpace`di titik akhir target Oracle Anda.
```
{
"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 Mengubah nama sebuah tablespace indeks Oracle**
Contoh berikut mengganti nama tablespace indeks bernama`SetISpace`untuk sebuah tabel bernama`Actor`di sumber Oracle Anda untuk`SceneIdxSpace`di titik akhir target Oracle Anda.
```
{
"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 Tambahkan kolom**
Contoh berikut menambahkan`datetime`kolom ke tabel`Actor`dalam skema`test`.
```
{
"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 Hapus kolom**
Contoh berikut mengubah tabel bernama`Actor`di sumber Anda untuk menghapus semua kolom yang dimulai dengan karakter`col`dari itu di target Anda.
```
{
"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 Mengkonversi ke lowercase**
Contoh berikut mengkonversi nama tabel dari`ACTOR`di sumber Anda untuk`actor`dalam target Anda.
```
{
"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 Mengkonversi ke huruf besar**
Contoh berikut mengkonversi semua kolom di semua tabel dan semua skema dari huruf kecil di sumber Anda untuk huruf besar dalam target Anda.
```
{
"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 Tambahkan prefiks**
Contoh berikut mengubah semua tabel di sumber Anda untuk menambahkan awalan`DMS_`kepada mereka dalam target Anda.
```
{
"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 Ganti awalan**
Contoh berikut mengubah semua kolom yang berisi awalan`Pre_`di sumber anda untuk mengganti awalan dengan`NewPre_`dalam target Anda.
```
{
"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 Hapus sufiks**
Contoh berikut mengubah semua tabel di sumber Anda untuk menghapus akhiran`_DMS`dari mereka di target Anda.
```
{
"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 Mendefinisikan kunci primer**
Contoh berikut mendefinisikan kunci primer bernama`ITEM-primary-key`pada tiga kolom`ITEM`tabel bermigrasi ke titik akhir target Anda.
```
{
"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 Tentukan indeks yang unik**
Contoh berikut mendefinisikan indeks unik bernama`ITEM-unique-idx`pada tiga kolom`ITEM`tabel bermigrasi ke titik akhir target Anda.
```
{
"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 Mengubah tipe data dari kolom target**
Contoh berikut mengubah tipe data dari kolom target bernama`SALE_AMOUNT`dari tipe data yang ada ke`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 Tambahkan kolom gambar sebelum**
Untuk kolom sumber bernama`emp_no`, aturan transformasi dalam contoh berikut menambahkan kolom baru bernama`BI_emp_no`target.
```
{
"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"
}
}
]
}
```
Di sini, pernyataan berikut populates`BI_emp_no`kolom di baris yang sesuai dengan 1.
```
UPDATE employees SET emp_no = 3 WHERE BI_emp_no = 1;
```
Saat menulis pembaruan CDC ke AWS DMS target yang didukung, `BI_emp_no` kolom memungkinkan untuk mengetahui baris mana yang memiliki nilai terbaru di `emp_no` kolom.
# Menggunakan ekspresi aturan transformasi untuk menentukan isi kolom
Untuk menentukan konten untuk kolom baru dan yang sudah ada, Anda dapat menggunakan ekspresi dalam aturan transformasi. Misalnya, menggunakan ekspresi Anda dapat menambahkan kolom atau mereplikasi header tabel sumber ke target. Anda juga dapat menggunakan ekspresi untuk menandai catatan pada tabel target sebagai dimasukkan, diperbarui, atau dihapus pada sumber.
**Topics**
+ [
## Menambahkan kolom menggunakan ekspresi
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-adding)
+ [
## Menandai catatan target menggunakan ekspresi
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Flagging)
+ [
## Replikasi header tabel sumber menggunakan ekspresi
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Headers)
+ [
## Menggunakan SQLite fungsi untuk membangun ekspresi
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite)
+ [
## Menambahkan metadata ke tabel target menggunakan ekspresi
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Metadata)
## Menambahkan kolom menggunakan ekspresi
Untuk menambahkan kolom ke tabel menggunakan ekspresi dalam aturan transformasi, gunakan`add-column`aturan tindakan dan`column`Target aturan.
Contoh berikut menambahkan kolom baru ke`ITEM`Tabel. Ini menetapkan nama kolom baru untuk`FULL_NAME`, dengan tipe data`string`, 50 karakter panjang. Ekspresi menggabungkan nilai-nilai dari dua kolom yang ada,`FIRST_NAME`dan`LAST_NAME`, untuk mengevaluasi`FULL_NAME`. Parameter`schema-name`,`table-name`, dan parameter ekspresi mengacu pada objek dalam tabel database sumber.`Value`dan`data-type`mengacu pada obyek dalam tabel basisdata target.
```
{
"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
}
}
]
}
```
## Menandai catatan target menggunakan ekspresi
Untuk menandai catatan dalam tabel target sebagai dimasukkan, diperbarui, atau dihapus dalam tabel sumber, menggunakan ekspresi dalam aturan transformasi. Ekspresi menggunakan`operation_indicator`fungsi untuk menandai catatan. Rekaman yang dihapus dari sumber tidak dihapus dari target. Sebaliknya, data target ditandai dengan nilai yang disediakan pengguna untuk menunjukkan bahwa itu telah dihapus dari sumber.
**catatan**
`operation_indicator`Fungsi ini hanya berfungsi pada tabel yang memiliki kunci utama pada basis data sumber dan target.
Sebagai contoh, aturan transformasi berikut pertama menambahkan baru`Operation`kolom ke tabel target. Kemudian update kolom dengan nilai`D`setiap kali catatan dihapus dari tabel sumber.
```
{
"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
}
}
```
## Replikasi header tabel sumber menggunakan ekspresi
Secara default, header untuk tabel sumber tidak direplikasi ke target. Untuk menunjukkan header untuk mereplikasi, menggunakan aturan transformasi dengan ekspresi yang mencakup header kolom tabel.
Anda dapat menggunakan header kolom berikut dalam ekspresi.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.html)
Contoh berikut menambahkan kolom baru ke target dengan menggunakan nilai posisi aliran dari sumber. Untuk SQL Server, nilai posisi aliran adalah LSN untuk titik akhir sumber. Untuk Oracle, nilai posisi aliran adalah SCN untuk titik akhir sumber.
```
{
"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
}
}
```
Contoh berikut menambahkan kolom baru ke target yang memiliki nomor incrementing unik dari sumber. Nilai ini mewakili 35 digit nomor unik di tingkat tugas. 16 digit pertama adalah bagian dari timestamp, dan 19 digit terakhir adalah jumlah record\$1id bertambah oleh DBMS.
```
{
"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
}
}
```
## Menggunakan SQLite fungsi untuk membangun ekspresi
Anda menggunakan pengaturan tabel untuk menentukan pengaturan yang ingin Anda terapkan ke tabel yang dipilih atau tampilan untuk operasi tertentu. Aturan pengaturan meja bersifat opsional.
**catatan**
Alih-alih konsep tabel dan pandangan, MongoDB dan database DocumentDB menyimpan catatan data sebagai dokumen yang berkumpul bersama-sama di*Koleksi*. Jadi kemudian, ketika bermigrasi dari MongoDB atau sumber DocumentDB, mempertimbangkan jenis rentang segmentasi pengaturan beban paralel untuk dipilih*Koleksi*bukan tabel dan pandangan.
**Topics**
+ [
### Menggunakan ekspresi CASE
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.CASE)
+ [
### Contoh
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.Ex)
Berikut ini, Anda dapat menemukan fungsi string yang dapat Anda gunakan untuk membangun ekspresi aturan transformasi.
| Fungsi string | Deskripsi |
| --- | --- |
| `lower(x)` | `lower(x)`Fungsi mengembalikan salinan string *`x`* dengan semua karakter dikonversi ke huruf kecil. `lower`Fungsi bawaan bawaan hanya berfungsi untuk karakter ASCII. |
| `upper(x)` | `upper(x)`Fungsi mengembalikan salinan string *`x`* dengan semua karakter dikonversi ke huruf besar. `upper`Fungsi bawaan bawaan hanya berfungsi untuk karakter ASCII. |
| `ltrim(x,y)` | `ltrim(x,y)`Fungsi mengembalikan string yang dibentuk dengan menghapus semua karakter yang muncul di y dari sisi kiri x. Jika tidak ada nilai untuk y, `ltrim(x)` hapus spasi dari sisi kiri x. |
| `replace(x,y,z)` | `replace(x,y,z)`Fungsi mengembalikan string dibentuk dengan mengganti string z untuk setiap kejadian string y dalam string x. |
| `rtrim(x,y)` | `rtrim(x,y)`Fungsi mengembalikan string yang dibentuk dengan menghapus semua karakter yang muncul di y dari sisi kanan x. Jika tidak ada nilai untuk y, `rtrim(x)` hapus spasi dari sisi kanan x. |
| `substr(x,y,z)` | `substr(x,y,z)`Fungsi mengembalikan substring dari string input `x` yang dimulai dengan karakter `y` th, dan yang merupakan *`z`* karakter panjang. Jika *`z`* dihilangkan, `substr(x,y)` mengembalikan semua karakter melalui akhir string `x` dimulai dengan karakter `y` th. Karakter paling kiri `x` adalah nomor 1. Jika *`y`* negatif, karakter pertama substring ditemukan dengan menghitung dari kanan daripada kiri. Jika *`z`* negatif, maka `abs(z)` karakter yang mendahului karakter ke `y` - dikembalikan. Jika `x` adalah string, maka indeks karakter mengacu pada karakter UTF-8 yang sebenarnya. Jika `x` adalah BLOB, maka indeks mengacu pada byte. |
| trim(x,y) | `trim(x,y)`Fungsi mengembalikan string dibentuk dengan menghapus semua karakter yang muncul di `y` dari kedua sisi`x`. Jika tidak ada nilai untuk`y`, `trim(x)` menghapus spasi dari kedua sisi`x`. |
Berikut ini, Anda dapat menemukan fungsi LOB yang dapat Anda gunakan untuk membangun ekspresi aturan transformasi.
| Fungsi LOB | Deskripsi |
| --- | --- |
| `hex(x)` | `hex`Fungsi menerima BLOB sebagai argumen dan mengembalikan versi string heksadesimal huruf besar dari konten BLOB. |
| `randomblob (N)` | `randomblob(N)`Fungsi mengembalikan BLOB `N` -byte yang berisi byte pseudorandom. Jika *N* kurang dari 1, BLOB acak 1-byte dikembalikan. |
| `zeroblob(N)` | `zeroblob(N)`Fungsi mengembalikan BLOB yang terdiri dari `N` byte 0x00. |
Berikut ini, Anda dapat menemukan fungsi numerik yang dapat Anda gunakan untuk membangun ekspresi aturan transformasi.
| Fungsi numerik | Deskripsi |
| --- | --- |
| `abs(x)` | `abs(x)`Fungsi mengembalikan nilai absolut dari argumen `x` numerik. `abs(x)`Fungsi mengembalikan NULL jika *x* NULL. `abs(x)`Fungsi mengembalikan 0.0 jika **x** adalah string atau BLOB yang tidak dapat dikonversi ke nilai numerik. |
| `random()` | `random`Fungsi mengembalikan bilangan bulat pseudorandom antara -9,223,372,036,854,775.808 dan \$19,223,372,036,854.775,807. |
| `round (x,y)` | `round (x,y)`Fungsi mengembalikan nilai floating-point *x* dibulatkan ke *y* digit di sebelah kanan titik desimal. Jika tidak ada nilai untuk*y*, itu diasumsikan 0. |
| `max (x,y...)` | `max`Fungsi multiargument mengembalikan argumen dengan nilai maksimum, atau mengembalikan NULL jika argumen adalah NULL. `max`Fungsi mencari argumennya dari kiri ke kanan untuk argumen yang mendefinisikan fungsi penyusunan. Jika ditemukan, ia menggunakan fungsi penyusunan itu untuk semua perbandingan string. Jika tidak ada argumen untuk `max` mendefinisikan fungsi penyusunan, fungsi `BINARY` penyusunan digunakan. `max`Fungsi adalah fungsi sederhana ketika memiliki dua atau lebih argumen, tetapi beroperasi sebagai fungsi agregat jika memiliki argumen tunggal. |
| `min (x,y...)` | `min`Fungsi multiargument mengembalikan argumen dengan nilai minimum. `min`Fungsi mencari argumennya dari kiri ke kanan untuk argumen yang mendefinisikan fungsi penyusunan. Jika ditemukan, ia menggunakan fungsi penyusunan itu untuk semua perbandingan string. Jika tidak ada argumen untuk `min` mendefinisikan fungsi penyusunan, fungsi `BINARY` penyusunan digunakan. `min`Fungsi adalah fungsi sederhana ketika memiliki dua atau lebih argumen, tetapi beroperasi sebagai fungsi agregat jika memiliki argumen tunggal. |
Berikut ini, Anda dapat menemukan fungsi pemeriksaan NULL yang dapat Anda gunakan untuk membangun ekspresi aturan transformasi.
| Fungsi pemeriksaan NULL | Deskripsi |
| --- | --- |
| `coalesce (x,y...)` | `coalesce`Fungsi mengembalikan salinan argumen non-Null pertama, tetapi mengembalikan NULL jika semua argumen adalah NULL. Fungsi coalesce memiliki setidaknya dua argumen. |
| `ifnull(x,y)` | `ifnull`Fungsi mengembalikan salinan argumen non-Null pertama, tetapi mengembalikan NULL jika kedua argumen adalah NULL. `ifnull`Fungsi ini memiliki tepat dua argumen. `ifnull`Fungsinya sama `coalesce` dengan dua argumen. |
| `nullif(x,y)` | `nullif(x,y)`Fungsi mengembalikan salinan argumen pertama jika argumen yang berbeda, tetapi mengembalikan NULL jika argumen yang sama. `nullif(x,y)`Fungsi mencari argumennya dari kiri ke kanan untuk argumen yang mendefinisikan fungsi penyusunan. Jika ditemukan, ia menggunakan fungsi penyusunan itu untuk semua perbandingan string. Jika tidak ada argumen untuk nullif mendefinisikan fungsi penyusunan, maka fungsi penyusunan digunakan. `BINARY` |
Berikut ini, Anda dapat menemukan fungsi tanggal dan waktu yang dapat Anda gunakan untuk membangun ekspresi aturan transformasi.
| Fungsi tanggal dan waktu | Deskripsi |
| --- | --- |
| `date(timestring, modifier, modifier...)` | `date`Fungsi mengembalikan tanggal dalam format YYYY-MM-DD. |
| `time(timestring, modifier, modifier...)` | `time`Fungsi mengembalikan waktu dalam format HH: MM: SS. |
| `datetime(timestring, modifier, modifier...)` | `datetime`Fungsi mengembalikan tanggal dan waktu dalam format YYYY-MM-DD HH: MM: SS. |
| `julianday(timestring, modifier, modifier...)` | `julianday`Fungsi mengembalikan jumlah hari sejak siang di Greenwich pada 24 November 4714 SM. |
| `strftime(format, timestring, modifier, modifier...)` | `strftime`Fungsi mengembalikan tanggal sesuai dengan format string ditentukan sebagai argumen pertama, menggunakan salah satu variabel berikut: `%d`: hari bulan `%H`: jam 00—24 `%f`: \$1\$1 pecahan detik SS.SSS `%j`: hari tahun 001—366 `%J`: \$1\$1 Nomor hari Julian `%m`: bulan 01—12 `%M`: menit 00—59 `%s`: detik sejak 1970-01-01 `%S`: detik 00—59 `%w`: hari dalam seminggu 0—6 Minggu==0 `%W`: minggu tahun 00—53 `%Y`: tahun 0000—9999 `%%`: % |
Berikut ini, Anda dapat menemukan fungsi hash yang dapat Anda gunakan untuk membangun ekspresi aturan transformasi.
| Fungsi hash | Deskripsi |
| --- | --- |
| `hash_sha256(x)` | `hash`Fungsi ini menghasilkan nilai hash untuk kolom input (menggunakan algoritma SHA-256) dan mengembalikan nilai heksadesimal dari nilai hash yang dihasilkan. Untuk menggunakan `hash` fungsi dalam ekspresi, tambahkan `hash_sha256(x)` ke ekspresi dan ganti *`x`* dengan nama kolom sumber. |
### Menggunakan ekspresi CASE
SQLite `CASE`Ekspresi mengevaluasi daftar kondisi dan mengembalikan ekspresi berdasarkan hasil. Sintaks ditampilkan sebagai berikut.
```
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
```
### Contoh
**Example menambahkan kolom string baru ke tabel target menggunakan kondisi kasus**
Contoh aturan transformasi berikut menambahkan kolom string baru,`emp_seniority`, ke tabel target,`employee`. Ini menggunakan SQLite `round` fungsi pada kolom gaji, dengan kondisi kasus untuk memeriksa apakah gaji sama atau melebihi 20.000. Jika ya, kolom mendapatkan nilai`SENIOR`, dan hal lain memiliki nilai`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 menambahkan kolom string baru ke tabel target menggunakan fungsi SUBSTR**
Contoh aturan transformasi berikut menambahkan kolom string baru menggunakan SQLite operator atau fungsi untuk menentukan data dalam kolom. Pendekatan ini melibatkan penggunaan SQLite fungsi untuk mengubah data GUID yang dimuat dari Oracle ke format UUID sebelum memasukkannya ke dalam tabel target Postgresql.
Aturan berikut menggunakan fungsi SQLite substring (SUBSTR), fungsi heksadesimal (HEX), dan huruf kecil (RENDAH) untuk memecah data GUID menjadi beberapa kelompok yang dipisahkan oleh tanda hubung, khususnya sekelompok 8 digit diikuti oleh tiga kelompok 4 digit diikuti oleh sekelompok 12 digit, dengan total 32 digit yang mewakili 128 bit.
Berikut adalah data sumber sampel dan output pada pemrosesan pasca target melalui aturan transformasi:
**Tabel Sumber (format Oracle GUID)**
T\$1 COL2
```
06F6949D234911EE80670242AC120002
1A2B3C4D5E6F11EE80670242AC120003
F5E4D3C2B1A011EE80670242AC120004
```
**Tabel Target (format PostgreSQL UUID)**
T\$1 \$1TMP COL2
```
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 menambahkan kolom tanggal baru ke tabel target**
Contoh berikut menambahkan kolom tanggal baru,`createdate`, ke tabel target,`employee`. Saat Anda menggunakan fungsi SQLite tanggal`datetime`, tanggal ditambahkan ke tabel yang baru dibuat untuk setiap baris yang disisipkan.
```
{
"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 menambahkan kolom numerik baru ke tabel target**
Contoh berikut menambahkan kolom numerik baru,`rounded_emp_salary`, ke tabel target,`employee`. Ini menggunakan SQLite `round` fungsi untuk menambah gaji bulat.
```
{
"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 menambahkan kolom string baru ke tabel target menggunakan fungsi hash**
Contoh berikut menambahkan kolom string baru,`hashed_emp_number`, ke tabel target,`employee`. SQLite`hash_sha256(x)`Fungsi ini menciptakan nilai hash pada target untuk kolom sumber,`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
}
}
```
## Menambahkan metadata ke tabel target menggunakan ekspresi
Anda dapat menambahkan informasi metadata ke tabel target dengan menggunakan ekspresi berikut:
+ `$AR_M_SOURCE_SCHEMA`— Nama skema sumber.
+ `$AR_M_SOURCE_TABLE_NAME`— Nama tabel sumber.
+ `$AR_M_SOURCE_COLUMN_NAME`— Nama kolom di tabel sumber.
+ `$AR_M_SOURCE_COLUMN_DATATYPE`— Tipe data kolom dalam tabel sumber.
**Example menambahkan kolom untuk nama skema menggunakan nama skema dari sumber**
Contoh berikut menambahkan kolom baru bernama `schema_name` target dengan menggunakan nama skema dari sumber.
```
{
"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
}
}
```
# Tabel dan koleksi pengaturan aturan dan operasi
Gunakan pengaturan tabel untuk menentukan pengaturan apa pun yang ingin Anda terapkan ke tabel atau tampilan yang dipilih untuk operasi tertentu. Aturan pengaturan tabel bersifat opsional, tergantung pada titik akhir dan persyaratan migrasi Anda.
*Alih-alih menggunakan tabel dan tampilan, database MongoDB dan Amazon DocumentDB menyimpan catatan data sebagai dokumen yang dikumpulkan bersama dalam koleksi.* Database tunggal untuk setiap titik akhir MongoDB atau Amazon DocumentDB adalah kumpulan koleksi tertentu yang diidentifikasi dengan nama database.
Saat bermigrasi dari sumber MongoDB atau Amazon DocumentDB, Anda bekerja dengan pengaturan beban paralel sedikit berbeda. Dalam hal ini, pertimbangkan jenis autosegmentasi atau segmentasi rentang pengaturan beban paralel untuk koleksi yang dipilih daripada tabel dan tampilan.
**Topics**
+ [
## Wildcard dalam pengaturan tabel dibatasi
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Wildcards)
+ [
## Menggunakan beban paralel untuk tabel, tampilan, dan koleksi yang dipilih
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad)
+ [
## Menentukan pengaturan LOB untuk tabel yang dipilih atau tampilan
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.LOB)
+ [
## Contoh pengaturan tabel
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Examples)
Untuk aturan pemetaan tabel yang menggunakan jenis aturan tabel-pengaturan, Anda dapat menerapkan parameter berikut.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)
## Wildcard dalam pengaturan tabel dibatasi
Menggunakan persen wildcard (`"%"`) dalam `"table-settings"` aturan tidak didukung untuk database sumber seperti yang ditunjukkan berikut.
```
{
"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
}
}
```
Jika Anda menggunakan `"%"` dalam `"table-settings"` aturan seperti yang ditunjukkan, kemudian AWS DMS mengembalikan pengecualian berikut.
```
Error in mapping rules. Rule with ruleId = x failed validation. Exact
schema and table name required when using table settings rule.
```
Selain itu, AWS merekomendasikan agar Anda tidak memuat banyak koleksi besar menggunakan satu tugas dengan`parallel-load`. Perhatikan bahwa AWS DMS membatasi pertentangan sumber daya serta jumlah segmen yang dimuat secara paralel dengan nilai parameter pengaturan `MaxFullLoadSubTasks` tugas, dengan nilai maksimum 49.
Sebagai gantinya, tentukan semua koleksi untuk database sumber Anda untuk koleksi terbesar dengan menentukan masing-masing `"schema-name"` dan satu `"table-name"` per satu. Juga, tingkatkan migrasi Anda dengan benar. Misalnya, jalankan beberapa tugas di sejumlah contoh replikasi yang cukup untuk menangani sejumlah besar koleksi besar dalam database Anda.
## Menggunakan beban paralel untuk tabel, tampilan, dan koleksi yang dipilih
Untuk mempercepat migrasi dan membuatnya lebih efisien, Anda dapat menggunakan beban paralel untuk tabel relasional, tampilan, dan koleksi yang dipilih. Dengan kata lain, Anda dapat memigrasikan satu tabel, tampilan, atau koleksi tersegmentasi menggunakan beberapa utas secara paralel. Untuk melakukan ini, AWS DMS membagi tugas beban penuh menjadi utas, dengan setiap segmen tabel dialokasikan ke utasnya sendiri.
Dengan menggunakan proses pemuatan paralel ini, pertama-tama Anda dapat meminta beberapa utas membongkar beberapa tabel, tampilan, dan koleksi secara paralel dari titik akhir sumber. Anda kemudian dapat memiliki beberapa thread yang bermigrasi dan memuat tabel, tampilan, dan koleksi yang sama secara paralel dengan titik akhir target. Untuk beberapa mesin database, Anda dapat segmen tabel dan pandangan oleh partisi yang ada atau subpartisi. Untuk mesin database lainnya, Anda dapat AWS DMS secara otomatis mengelompokkan koleksi sesuai dengan parameter tertentu (autosegmentasi). Jika tidak, Anda dapat mengelompokkan tabel, tampilan, atau koleksi apa pun berdasarkan rentang nilai kolom yang Anda tentukan.
Beban paralel didukung untuk endpoint sumber berikut:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2 LUW
+ SAP Adaptive Server Enterprise (ASE)
+ MongoDB (hanya mendukung opsi autosegmentasi dan segmentasi rentang dari beban penuh paralel)
+ Amazon DocumentDB (hanya mendukung opsi segmentasi otomatis dan segmentasi rentang beban penuh paralel)
Untuk titik akhir MongoDB dan Amazon DocumentDB AWS DMS , mendukung tipe data berikut untuk kolom yang merupakan kunci partisi untuk opsi segmentasi rentang beban penuh paralel.
+ Dua Kali
+ String
+ ObjectId
+ 32 bit integer
+ 64 bit integer
Beban paralel untuk digunakan dengan pengaturan tabel aturan yang didukung untuk target akhir berikut:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ Amazon S3
+ SAP Adaptive Server Enterprise (ASE)
+ Amazon Redshift
+ MongoDB (hanya mendukung opsi autosegmentasi dan segmentasi rentang dari beban penuh paralel)
+ Amazon DocumentDB (hanya mendukung opsi segmentasi otomatis dan segmentasi rentang beban penuh paralel)
+ Db2 LUW
Untuk menentukan jumlah maksimum tabel dan tampilan untuk memuat secara paralel, gunakan`MaxFullLoadSubTasks`pengaturan tugas.
Untuk menentukan jumlah maksimum utas per tabel atau tampilan untuk target yang didukung dari tugas beban paralel, tentukan lebih banyak segmen menggunakan batas nilai kolom.
**penting**
`MaxFullLoadSubTasks`mengontrol jumlah tabel atau segmen tabel untuk memuat secara paralel. `ParallelLoadThreads`mengontrol jumlah thread yang digunakan oleh tugas migrasi untuk mengeksekusi beban secara paralel. *Pengaturan ini bersifat multiplikatif*. **Dengan demikian, jumlah total utas yang digunakan selama tugas pemuatan penuh kira-kira merupakan hasil dari nilai `ParallelLoadThreads ` dikalikan dengan nilai `MaxFullLoadSubTasks` (`ParallelLoadThreads`\$1.** `MaxFullLoadSubtasks)`
Jika Anda membuat tugas dengan jumlah sub tugas Full Load yang tinggi dan sejumlah besar thread beban paralel, tugas Anda dapat menghabiskan terlalu banyak memori dan gagal.
Untuk menentukan jumlah maksimum thread per tabel untuk Amazon DynamoDB, Amazon Kinesis Data Streams, Apache Kafka, atau Amazon Elasticsearch Service target, gunakan setelan tugas metadata target. `ParallelLoadThreads`
Untuk menentukan ukuran buffer untuk tugas beban paralel saat `ParallelLoadThreads` digunakan, gunakan pengaturan tugas metadata `ParallelLoadBufferSize` target.
Ketersediaan dan pengaturan `ParallelLoadThreads` dan `ParallelLoadBufferSize` tergantung pada titik akhir target.
Untuk informasi selengkapnya tentang pengaturan `ParallelLoadThreads` dan `ParallelLoadBufferSize`, lihat [Menargetkan pengaturan tugas metadata](CHAP_Tasks.CustomizingTasks.TaskSettings.TargetMetadata.md). Untuk informasi selengkapnya tentang pengaturan `MaxFullLoadSubTasks`, lihat [Pengaturan tugas beban penuh](CHAP_Tasks.CustomizingTasks.TaskSettings.FullLoad.md). Untuk informasi yang spesifik untuk menargetkan titik akhir, lihat topik terkait.
Untuk menggunakan beban paralel, membuat aturan pemetaan tabel jenis`table-settings`dengan`parallel-load`Pilihan. Dalam `table-settings` aturan, Anda dapat menentukan kriteria segmentasi untuk satu tabel, tampilan, atau koleksi yang ingin Anda muat secara paralel. Untuk melakukannya, tetapkan parameter `type` dari opsi `parallel-load` untuk salah satu dari beberapa opsi.
Cara melakukannya tergantung pada bagaimana Anda ingin mengelompokkan tabel, tampilan, atau koleksi untuk beban paralel:
+ Dengan partisi (atau segmen) - Muat semua tabel yang ada atau lihat partisi (atau segmen) menggunakan tipe. `partitions-auto` Atau muat hanya partisi yang dipilih menggunakan `partitions-list` tipe dengan array partisi tertentu.
Hanya untuk titik akhir MongoDB dan Amazon DocumentDB, muat semua atau koleksi tertentu berdasarkan segmen AWS DMS yang secara otomatis menghitung juga menggunakan jenis dan parameter opsional tambahan. `partitions-auto` `table-settings`
+ (Oracle endpoint saja) Dengan subpartisi — Muat semua tabel yang ada atau lihat subpartisi menggunakan`subpartitions-auto`Jenis. Atau memuat hanya subpartisi yang dipilih menggunakan`partitions-list`ketik dengan dispesifikasikan`subpartitions`Array.
+ Berdasarkan segmen yang Anda tentukan — Muat tabel, tampilan, atau segmen koleksi yang Anda tentukan dengan menggunakan batas nilai kolom. Untuk melakukannya, gunakan`ranges`tipe dengan dispesifikasikan`columns`dan`boundaries`Susunan.
**catatan**
PostgreSQL endpoint hanya mendukung jenis beban paralel ini. MongoDB dan Amazon DocumentDB sebagai titik akhir sumber mendukung jenis segmentasi rentang ini dan tipe autosegmentasi dari beban penuh paralel (). `partitions-auto`
Untuk mengidentifikasi tabel, tampilan, atau koleksi tambahan untuk dimuat secara paralel, tentukan `table-settings` objek tambahan dengan `parallel-load` opsi.
Dalam prosedur berikut, Anda dapat mengetahui cara mengkodekan JSON untuk setiap jenis beban paralel, dari yang paling sederhana hingga yang paling kompleks.
**Untuk menentukan semua tabel, tampilan, atau koleksi partisi, atau semua tabel atau tampilan subpartisi**
+ Tentukan`parallel-load`dengan baik`partitions-auto`Jenis atau`subpartitions-auto`jenis (tetapi tidak keduanya).
Setiap tabel, tampilan, atau partisi koleksi (atau segmen) atau subpartisi kemudian secara otomatis dialokasikan ke utasnya sendiri.
Untuk beberapa titik akhir, beban paralel mencakup partisi atau subpartisi hanya jika sudah ditentukan untuk tabel atau tampilan. Untuk titik akhir sumber MongoDB dan Amazon DocumentDB, Anda dapat AWS DMS menghitung partisi (atau segmen) secara otomatis berdasarkan parameter tambahan opsional. Ini termasuk `number-of-partitions`, `collection-count-from-metadata`, `max-records-skip-per-page`, dan `batch-size`.
**Untuk menentukan tabel yang dipilih atau tampilan partisi, subpartisi, atau keduanya**
1. Tentukan`parallel-load`dengan`partitions-list`Jenis.
1. (Opsional) Sertakan partisi dengan menentukan sebuah array dari nama partisi sebagai nilai dari`partitions`.
Setiap partisi yang ditentukan kemudian dialokasikan ke benangnya sendiri.
**penting**
Untuk endpoint Oracle, pastikan partisi dan subpartisi tidak tumpang tindih saat memilihnya untuk beban paralel. Jika Anda menggunakan partisi dan subpartisi yang tumpang tindih untuk memuat data secara paralel, itu menduplikasi entri, atau gagal karena pelanggaran duplikat kunci utama.
1. (Opsional), Untuk endpoint Oracle saja, sertakan subpartisi dengan menentukan array nama subpartisi sebagai nilai. `subpartitions`
Setiap subpartisi yang ditentukan kemudian dialokasikan ke benangnya sendiri.
**catatan**
Beban paralel mencakup partisi atau subpartisi hanya jika sudah ditentukan untuk tabel atau tampilan.
Anda dapat menentukan tabel atau tampilan segmen sebagai rentang nilai kolom. Ketika Anda melakukannya, menyadari karakteristik kolom ini:
+ Menentukan kolom diindeks secara signifikan meningkatkan kinerja.
+ Anda dapat menentukan hingga 10 kolom.
+ Anda tidak dapat menggunakan kolom untuk menentukan batas segmen dengan tipe AWS DMS data berikut: DOUBLE, FLOAT, BLOB, CLOB, dan NCLOB
+ Catatan dengan nilai null tidak direplikasi.
**Untuk menentukan tabel, tampilan, atau segmen koleksi sebagai rentang nilai kolom**
1. Tentukan`parallel-load`dengan`ranges`Jenis.
1. Mendefinisikan batas antara tabel atau tampilan segmen dengan menentukan array nama kolom sebagai nilai`columns`. Lakukan ini untuk setiap kolom yang Anda ingin menentukan batas antara tabel atau tampilan segmen.
Urutan kolom adalah signifikan. Kolom pertama adalah yang paling signifikan dan kolom terakhir paling tidak signifikan dalam mendefinisikan setiap batas, seperti yang dijelaskan berikut.
1. Mendefinisikan rentang data untuk semua tabel atau tampilan segmen dengan menentukan array batas sebagai nilai`boundaries`. A*batas array*adalah array dari array kolom-nilai. Untuk melakukannya, ikuti langkah-langkah berikut ini:
1. Tentukan setiap elemen dari array kolom-nilai sebagai nilai yang sesuai dengan setiap kolom. A*array kolom-nilai*mewakili batas atas setiap tabel atau tampilan segmen yang ingin Anda definisikan. Tentukan setiap kolom dalam urutan yang sama yang Anda tentukan kolom di`columns`Array.
Masukkan nilai untuk kolom DATE dalam format yang didukung oleh sumber.
1. Tentukan setiap larik nilai kolom sebagai batas atas, secara berurutan, dari setiap segmen dari bawah ke next-to-top segmen tabel atau tampilan. Jika ada baris di atas batas atas yang Anda tentukan, baris ini menyelesaikan segmen atas tabel atau tampilan. Dengan demikian, jumlah segmen berbasis rentang berpotensi satu lebih dari jumlah batas segmen dalam array batas. Setiap segmen berbasis rentang tersebut dialokasikan ke benangnya sendiri.
Semua data non-null direplikasi, bahkan jika Anda tidak menentukan rentang data untuk semua kolom dalam tabel atau tampilan.
Misalnya, anggaplah Anda mendefinisikan tiga array nilai kolom untuk kolom COL1 COL2, dan COL3 sebagai berikut.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)
Anda telah menetapkan batas tiga segmen untuk kemungkinan total empat segmen.
Untuk mengidentifikasi rentang baris untuk mereplikasi untuk setiap segmen, contoh replikasi berlaku pencarian untuk tiga kolom ini untuk masing-masing empat segmen. Pencarian adalah sebagai berikut:
**Segmen 1**
Mereplikasi semua baris di mana berikut ini benar: Nilai dua kolom pertama kurang dari atau sama dengan mereka yang sesuai**Segmen 1**nilai batas atas. Juga, nilai-nilai kolom ketiga kurang dari yang**Segmen 1**nilai batas atas.
**Segmen 2**
Mereplikasi semua baris (kecuali**Segmen 1**baris) di mana berikut ini benar: Nilai dua kolom pertama kurang dari atau sama dengan mereka yang sesuai**Segmen 2**nilai batas atas. Juga, nilai-nilai kolom ketiga kurang dari yang**Segmen 2**nilai batas atas.
**Segmen 3**
Mereplikasi semua baris (kecuali**Segmen 2**baris) di mana berikut ini benar: Nilai dua kolom pertama kurang dari atau sama dengan mereka yang sesuai**Segmen 3**nilai batas atas. Juga, nilai-nilai kolom ketiga kurang dari yang**Segmen 3**nilai batas atas.
**Segmen 4**
Mereplikasi semua baris yang tersisa (kecuali**Segmen 1, 2, dan 3**baris).
Dalam kasus ini, contoh replikasi menciptakan`WHERE`klausul untuk memuat setiap segmen sebagai berikut:
**Segmen 1**
`((COL1 < 10) OR ((COL1 = 10) AND (COL2 < 30)) OR ((COL1 = 10) AND (COL2 = 30) AND (COL3 < 105)))`
**Segmen 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)))`
**Segmen 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)))`
**Segmen 4**
`NOT ((COL1 < 100) OR ((COL1 = 100) AND (COL2 < 12)) OR ((COL1 = 100) AND (COL2 = 12) AND (COL3 < 99)))`
## Menentukan pengaturan LOB untuk tabel yang dipilih atau tampilan
Anda dapat mengatur pengaturan LOB tugas untuk satu atau lebih tabel dengan menciptakan aturan pemetaan tabel jenis`table-settings`dengan`lob-settings`pilihan untuk satu atau lebih`table-settings`objek.
Menentukan pengaturan LOB untuk dipilih tabel atau tampilan didukung untuk endpoint sumber berikut:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2, tergantung pada`mode`dan`bulk-max-size`, dijelaskan sebagai berikut
+ SAP Adaptive Server Enterprise (ASE), tergantung pada`mode`dan`bulk-max-size`pengaturan, seperti yang dijelaskan berikut
Menentukan pengaturan LOB untuk dipilih tabel atau tampilan didukung untuk target akhir berikut:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ SAP ASE, tergantung pada`mode`dan`bulk-max-size`pengaturan, seperti yang dijelaskan berikut
**catatan**
Anda dapat menggunakan LOB tipe data hanya dengan tabel dan pandangan yang mencakup kunci primer.
Untuk menggunakan pengaturan LOB untuk tabel yang dipilih atau tampilan, Anda membuat aturan pemetaan tabel jenis`table-settings`dengan`lob-settings`Pilihan. Melakukan hal ini menentukan LOB penanganan untuk tabel atau tampilan diidentifikasi oleh`object-locator`Pilihan. Dalam`table-settings`aturan, Anda dapat menentukan`lob-settings`objek dengan parameter berikut:
+ `mode`— Menentukan mekanisme penanganan migrasi LOB untuk tabel yang dipilih atau lihat sebagai berikut:
+ `limited`— Mode LOB terbatas default adalah mode tercepat dan paling efisien. Gunakan mode ini hanya jika semua Anda LOBs kecil (dalam ukuran 100 MB) atau titik akhir target tidak mendukung ukuran LOB yang tidak terbatas. Juga jika Anda menggunakan`limited`, semua LOBs harus dalam ukuran yang Anda tetapkan`bulk-max-size`.
Dalam mode ini untuk tugas beban penuh, instance replikasi memigrasikan semua LOBs inline bersama dengan tipe data kolom lainnya sebagai bagian dari tabel utama atau penyimpanan tampilan. Namun, contoh memotong LOB bermigrasi lebih besar dari`bulk-max-size`nilai untuk ukuran yang ditentukan. Untuk tugas pemuatan change data capture (CDC), instance akan memigrasikan semua LOBs menggunakan pencarian tabel sumber, seperti dalam mode LOB penuh standar (lihat berikut ini).
**catatan**
Anda dapat memigrasi tampilan untuk tugas penuh saja.
+ `unlimited`— Mekanisme migrasi untuk mode LOB penuh tergantung pada nilai yang Anda tetapkan untuk`bulk-max-size`sebagai berikut:
+ **Mode LOB penuh standar** — Saat Anda menyetel `bulk-max-size` ke nol, instance replikasi akan memigrasikan semua LOBs menggunakan mode LOB penuh standar. Mode ini memerlukan pencarian dalam tabel sumber atau tampilan untuk bermigrasi setiap LOB, terlepas dari ukuran. Pendekatan ini biasanya menghasilkan migrasi jauh lebih lambat daripada untuk modus LOB terbatas. Gunakan mode ini hanya jika semua atau sebagian besar Anda LOBs berukuran besar (1 GB atau lebih besar).
+ **Kombinasi mode LOB penuh**— Saat Anda mengatur`bulk-max-size`ke nilai nol, mode LOB penuh ini menggunakan kombinasi mode LOB terbatas dan standar modus LOB penuh. Itu adalah untuk tugas beban penuh, jika ukuran LOB dalam Anda`bulk-max-size`nilai, misalnya bermigrasi LOB inline seperti dalam modus LOB terbatas. Jika ukuran LOB lebih besar dari nilai ini, contoh bermigrasi LOB menggunakan tabel sumber atau tampilan pencarian seperti dalam mode LOB penuh standar. Untuk tugas pemuatan change data capture (CDC), instance akan memigrasikan semua LOBs menggunakan pencarian tabel sumber, seperti dalam mode LOB penuh standar (lihat berikut ini). Hal itu tidak terlepas dari ukuran LOB.
**catatan**
Anda dapat memigrasi tampilan untuk tugas penuh saja.
Mode ini menghasilkan kecepatan migrasi yang kompromi antara lebih cepat, modus LOB terbatas dan lambat, modus LOB penuh standar. Gunakan mode ini hanya jika Anda memiliki campuran kecil dan besar LOBs, dan sebagian LOBs besar kecil.
Kombinasi mode LOB penuh ini tersedia hanya untuk endpoint berikut:
+ IBM Db2 sebagai sumber
+ SAP ASE sebagai sumber atau target
Terlepas dari mekanisme yang Anda tentukan untuk `unlimited` mode, instance memigrasikan semuanya LOBs sepenuhnya, tanpa pemotongan.
+ `none`— Instance replikasi bermigrasi LOBs dalam tabel atau tampilan yang dipilih menggunakan pengaturan LOB tugas Anda. Gunakan opsi ini untuk membantu membandingkan hasil migrasi dengan dan tanpa pengaturan LOB untuk tabel atau tampilan yang dipilih.
Jika tabel atau tampilan yang ditentukan telah LOBs disertakan dalam replikasi, Anda dapat mengatur pengaturan `BatchApplyEnabled` tugas `true` hanya saat menggunakan mode `limited` LOB.
Dalam beberapa kasus, Anda mungkin mengatur`BatchApplyEnabled`ke`true`dan`BatchApplyPreserveTransaction`ke`false`. Dalam kasus ini, instance disetel `BatchApplyPreserveTransaction` ke `true` jika tabel atau tampilan memiliki LOBs dan titik akhir sumber dan target adalah Oracle.
+ `bulk-max-size`— Set nilai ini ke nilai nol atau bukan nol dalam kilobyte, tergantung pada`mode`seperti yang dijelaskan untuk item sebelumnya. Masuk`limited`mode, Anda harus menetapkan nilai bukan nol untuk parameter ini.
Instance mengkonversi LOBs ke format biner. Oleh karena itu, untuk menentukan LOB terbesar Anda perlu mereplikasi, kalikan ukurannya dengan tiga. Misalnya, jika LOB terbesar Anda adalah 2 MB, mengatur`bulk-max-size`hingga 6.000 (6 MB).
## Contoh pengaturan tabel
Berikut ini, Anda dapat menemukan beberapa contoh yang menunjukkan penggunaan pengaturan tabel.
**Example Memuat tabel tersegmentasi oleh partisi**
Contoh berikut memuat`SALES`tabel di sumber Anda lebih efisien dengan memuatnya secara paralel berdasarkan semua partisi.
```
{
"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 Memuat tabel tersegmentasi oleh subpartisi**
Contoh berikut memuat`SALES`tabel di sumber Oracle Anda lebih efisien dengan memuat secara paralel berdasarkan semua subpartisi nya.
```
{
"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 Memuat tabel tersegmentasi oleh daftar partisi**
Contoh berikut memuat`SALES`tabel di sumber Anda dengan memuatnya secara paralel dengan daftar partisi tertentu. Di sini, partisi yang ditentukan diberi nama setelah nilai dimulai dengan bagian dari alfabet, misalnya`ABCD`,`EFGH`, dan sebagainya.
```
{
"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 Memuat tabel Oracle tersegmentasi oleh daftar yang dipilih dari partisi dan subpartisi**
Contoh berikut memuat`SALES`tabel di sumber Oracle Anda dengan memuatnya secara paralel dengan daftar partisi dan subpartisi yang dipilih. Di sini, partisi yang ditentukan diberi nama setelah nilai dimulai dengan bagian dari alfabet, misalnya`ABCD`,`EFGH`, dan sebagainya. Subpartisi yang ditentukan diberi nama sesuai nilai yang dimulai dengan angka, misalnya`01234`dan`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 Memuat tabel tersegmentasi dengan rentang nilai kolom**
Contoh berikut memuat`SALES`tabel di sumber Anda dengan memuatnya secara paralel oleh segmen yang ditentukan oleh rentang`SALES_NO`dan`REGION`nilai kolom.
```
{
"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"
]
]
}
}
]
}
```
Di sini, dua kolom yang ditentukan untuk rentang segmen dengan nama,`SALES_NO`dan`REGION`. Dua batas ditentukan dengan dua set nilai kolom (`["1000","NORTH"]`dan`["3000","WEST"]`).
Kedua batas tersebut mengidentifikasi tiga segmen tabel berikut untuk memuat secara paralel:
Segmen 1
Baris dengan `SALES_NO` kurang dari atau sama dengan 1.000 dan `REGION`kurang dari “UTARA”. Dengan kata lain, angka penjualan hingga 1.000 di wilayah TIMUR.
Segmen 2
Baris selain dari **Segmen 1** dengan `SALES_NO` kurang dari atau sama dengan 3.000 dan `REGION` kurang dari “BARAT”. Dengan kata lain, jumlah penjualan lebih dari 1.000 hingga 3.000 di wilayah UTARA dan SELATAN.
Segmen 3
Semua baris yang tersisa selain**Segmen 1**dan**Segmen 2**. Dengan kata lain, jumlah penjualan lebih dari 3.000 di wilayah “WEST”.
**Example Memuat dua tabel: Satu tersegmentasi berdasarkan rentang dan lain tersegmentasi oleh partisi**
Contoh berikut memuat`SALES`tabel secara paralel dengan batas-batas segmen yang Anda mengidentifikasi. Hal ini juga memuat`ORDERS`tabel secara paralel oleh semua partisi, seperti contoh sebelumnya.
```
{
"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 Muat tabel dengan LOBs menggunakan pengaturan tugas LOB**
Contoh berikut memuat `ITEMS` tabel di sumber Anda, termasuk semua LOBs, menggunakan pengaturan LOB tugasnya. Parameter`bulk-max-size`pengaturan 100 MB diabaikan dan dibiarkan hanya untuk reset cepat`limited`atau`unlimited`Mode.
```
{
"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 Muat tabel dengan LOBs menggunakan mode LOB terbatas**
Contoh berikut memuat `ITEMS` tabel termasuk LOBs dalam sumber Anda menggunakan mode LOB terbatas (default) dengan ukuran maksimum tidak terpotong 100 MB. Apa pun LOBs yang lebih besar dari ukuran ini dipotong menjadi 100 MB. Semua LOBs dimuat sebaris dengan semua tipe data kolom lainnya.
```
{
"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 Muat tabel dengan LOBs menggunakan mode LOB penuh standar**
Contoh berikut memuat `ITEMS` tabel di sumber Anda, termasuk semua LOBs tanpa pemotongan, menggunakan mode LOB penuh standar. Semua LOBs, terlepas dari ukurannya, dimuat secara terpisah dari tipe data lain menggunakan pencarian untuk setiap LOB di tabel sumber.
```
{
"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 Muat tabel dengan LOBs menggunakan kombinasi mode LOB penuh**
Contoh berikut memuat `ITEMS` tabel di sumber Anda, termasuk semua LOBs tanpa pemotongan, menggunakan kombinasi mode LOB penuh. Semua LOBs dalam ukuran 100 MB dimuat sebaris bersama dengan tipe data lainnya, seperti dalam mode LOB terbatas. Seluruh LOBs lebih dari 100 MB dalam ukuran dimuat secara terpisah dari tipe data lainnya. Beban terpisah ini menggunakan pencarian untuk masing-masing LOB tersebut dalam tabel sumber, seperti dalam modus LOB penuh standar.
```
{
"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"
}
}
]
}
```
# Menggunakan masking data untuk menyembunyikan informasi sensitif
Untuk menyembunyikan data sensitif yang disimpan dalam satu atau beberapa kolom tabel yang sedang dimigrasi, Anda dapat memanfaatkan tindakan aturan transformasi Masking Data. Mulai dari versi 3.5.4, AWS DMS memungkinkan penggunaan tindakan aturan transformasi masking data dalam pemetaan tabel, memungkinkan Anda untuk mengubah isi dari satu atau beberapa kolom selama proses migrasi. AWS DMS memuat data yang dimodifikasi ke dalam tabel target.
AWS Database Migration Service menyediakan tiga opsi untuk tindakan aturan transformasi masking data:
+ Masking Data: Topeng Digit
+ Masking Data: Digit Acak
+ Masking Data: Topeng Hashing
Tindakan aturan transformasi masking data ini dapat dikonfigurasi dalam pemetaan tabel tugas replikasi Anda, mirip dengan aturan transformasi lainnya. Target aturan harus diatur ke tingkat kolom.
## Masking angka dalam data kolom dengan karakter masking
Tindakan aturan transformasi “Data Masking: Digit Mask” memungkinkan Anda untuk menutupi data numerik dalam satu atau beberapa kolom dengan mengganti digit dengan satu karakter ASCII yang dapat dicetak yang Anda tentukan (tidak termasuk karakter kosong atau spasi putih).
Berikut adalah contoh yang menutupi semua digit di `cust_passport_no` kolom `customer_master` tabel dengan karakter masking `'#'` dan memuat data bertopeng ke dalam tabel target:
```
{
"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": "#"
}
]
}
```
Misalnya, jika kolom `cust_passport_no` di tabel sumber berisi catatan “C6 BGJ566669 K”, AWS DMS tugas akan menulis data ini ke tabel target sebagai`"C#BGJ######K"`.
## Mengganti angka di kolom dengan angka acak
Aturan transformasi “Data Masking: Digit Randomize” memungkinkan Anda untuk mengganti setiap digit numerik dalam satu atau lebih kolom dengan nomor acak. Dalam contoh berikut, AWS DMS ganti setiap digit di `cust_passport_no` kolom tabel sumber `customer_master` dengan nomor acak dan tulis data yang dimodifikasi ke tabel target:
```
{
"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"
}
]
}
```
Misalnya, AWS DMS tugas akan mengubah nilai `"C6BGJ566669K"` di `cust_passport_no` kolom tabel sumber `"C1BGJ842170K"` dan menuliskannya ke database target.
## Mengganti data kolom dengan nilai hash
Aturan transformasi “Data Masking: Hashing Mask” memungkinkan Anda mengganti data kolom dengan hash yang dihasilkan menggunakan algoritma. `SHA256` Panjang hash akan selalu 64 karakter, maka panjang kolom tabel target harus minimal 64 karakter. Atau, Anda dapat menambahkan tindakan aturan `change-data-type` transformasi ke kolom untuk menambah lebar kolom dalam tabel target.
Contoh berikut menghasilkan nilai hash panjang 64 karakter untuk data di `cust_passport_no` kolom tabel sumber `customer_master` dan memuat data yang diubah ke tabel target setelah menambah panjang kolom:
```
{
"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"
}
]
}
```
Misalnya, jika kolom `cust_passport_no` tabel sumber berisi nilai`“C6BGJ566669K”`, AWS DMS tugas akan menulis hash `“7CB06784764C9030CCC41E25C15339FEB293FFE9B329A72B5FED564E99900C75”` ke tabel target.
## Batasan
+ Setiap opsi aturan transformasi Masking Data didukung hanya untuk tipe AWS DMS data tertentu:
+ Data Masking: Digit Mask didukung untuk kolom tipe data: `WSTRING` dan. `STRING`
+ Data Masking: Digit Randomize didukung untuk kolom tipe data: `WSTRING, STRING; NUMERIC, INT1, INT2, INT4, and INT8 ` dengan rekan yang tidak ditandatangani.
+ Data Masking: Hashing Mask didukung untuk kolom tipe data: `WSTRING` dan. `STRING`
Untuk mempelajari lebih lanjut tentang pemetaan tipe AWS DMS data ke tipe data mesin sumber Anda, lihat pemetaan tipe data mesin sumber Anda dengan tipe AWS DMS data. Lihat tipe data sumber untuk[Jenis data sumber untuk Oracle](CHAP_Source.Oracle.md#CHAP_Source.Oracle.DataTypes),[Jenis sumber data untuk SQL Server](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.DataTypes),[Jenis data sumber untuk PostgreSQL](CHAP_Source.PostgreSQL.md#CHAP_Source-PostgreSQL-DataTypes), dan[Jenis data sumber untuk MySQL](CHAP_Source.MySQL.md#CHAP_Source.MySQL.DataTypes).
+ Menggunakan tindakan aturan Masking Data untuk kolom dengan tipe data yang tidak kompatibel akan menyebabkan kesalahan dalam tugas DMS. Lihat DataMaskingErrorPolicy dalam pengaturan tugas DMS untuk menentukan perilaku penanganan kesalahan. Untuk informasi selengkapnya tentang `DataMaskingErrorPolicy`, lihat [Penanganan kesalahan pengaturan tugas](CHAP_Tasks.CustomizingTasks.TaskSettings.ErrorHandling.md).
+ Anda dapat menambahkan tindakan aturan change-data-type transformasi untuk mengubah tipe data kolom menjadi tipe yang kompatibel jika jenis kolom sumber Anda tidak didukung untuk opsi masking yang ingin Anda gunakan. `change-data-type`Transformasi harus lebih kecil dari rule-id dari transformasi masking sehingga perubahan tipe data terjadi sebelum masking. `rule-id`
+ Gunakan Data Masking: Tindakan Hashing Mask untuk menutupi kolom Kunci Primer/Kunci Unik/Kunci Asing, karena nilai hash yang dihasilkan akan unik dan konsisten. Dua opsi masking lainnya tidak dapat menjamin keunikan.
+ Sementara Data Masking: Digit Mask dan Data Masking: Digit Randomize hanya mempengaruhi digit dalam data kolom dan tidak mempengaruhi panjang data, Data Masking: Hashing Mask memodifikasi seluruh kolom, panjang data berubah menjadi 64 karakter. Oleh karena itu, tabel target yang akan dibuat sesuai atau aturan change-data-type transformasi harus ditambahkan untuk kolom yang sedang ditutupi.
+ Kolom dengan tindakan aturan transformasi Masking Data yang ditentukan dikecualikan dari validasi data di. AWS DMS Jika kolom Kunci Primer/Kunci Unik ditutupi, validasi data tidak akan dijalankan untuk tabel ini; status validasi tabel tersebut akan sama dengan. `No Primary key`