Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menghubungkan ke Gudang Data Teradata dengan AWS Schema Conversion Tool
Anda dapat menggunakan AWS SCT untuk mengonversi skema, objek kode, dan kode aplikasi dari Teradata ke Amazon Redshift atau Amazon Redshift dan digunakan dalam kombinasi. AWS Glue
## Hak istimewa untuk Teradata sebagai sumber
Hak istimewa berikut diperlukan untuk menggunakan Teradata sebagai sumber:
+ PILIH DI DBC
+ PILIH DI SYSUDTLIB
+ PILIH PADA SYSLIB
+ PILIH PADA **
+ BUAT PROSEDUR PADA **
Pada contoh sebelumnya, ganti ** placeholder dengan nama database sumber.
AWS SCT memerlukan hak istimewa CREATE PROCEDURE untuk melakukan PROSEDUR BANTUAN terhadap semua prosedur dalam database sumber. AWS SCT tidak menggunakan hak istimewa ini untuk membuat objek baru di database Teradata sumber Anda.
## Menghubungkan ke Teradata sebagai sumber
Gunakan prosedur berikut untuk terhubung ke database sumber Teradata Anda dengan file. AWS Schema Conversion Tool
**Untuk terhubung ke database sumber Teradata**
1. Di dalam AWS Schema Conversion Tool, pilih **Tambahkan sumber**.
1. **Pilih **Teradata**, lalu pilih Berikutnya.**
Kotak dialog **Tambah sumber** muncul.
1. Untuk **nama Koneksi**, masukkan nama untuk database Anda. AWS SCT menampilkan nama ini di pohon di panel kiri.
1. Gunakan kredensi database dari AWS Secrets Manager atau masukkan secara manual:
+ Untuk menggunakan kredensi database dari Secrets Manager, gunakan petunjuk berikut:
1. Untuk **AWS Rahasia**, pilih nama rahasianya.
1. **Pilih Isi untuk secara otomatis mengisi semua nilai di kotak dialog koneksi database dari Secrets Manager.**
Untuk informasi tentang menggunakan kredensil database dari Secrets Manager, lihat. [Mengkonfigurasi AWS Secrets Manager di AWS Schema Conversion Tool](CHAP_UserInterface.SecretsManager.md)
+ Untuk memasukkan informasi koneksi database sumber Teradata secara manual, gunakan petunjuk berikut:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/SchemaConversionTool/latest/userguide/CHAP_Source.Teradata.html)
1. Pilih **Uji Koneksi** untuk memverifikasi bahwa AWS SCT dapat terhubung ke database sumber Anda.
1. Pilih **Connect** untuk terhubung ke database sumber Anda.
### Menggunakan otentikasi LDAP dengan sumber Teradata
Untuk mengatur otentikasi Lightweight Directory Access Protocol (LDAP) untuk pengguna Teradata yang menjalankan Microsoft Active Directory di Windows, gunakan prosedur berikut.
Dalam prosedur berikut, domain Active Directory adalah`test.local.com`. Server Windows adalah`DC`, dan dikonfigurasi dengan pengaturan default. Skrip berikut membuat akun `test_ldap` Active Directory, dan akun ini menggunakan `test_ldap` kata sandi.
**Untuk mengatur otentikasi LDAP untuk pengguna Teradata yang menjalankan Microsoft Active Directory di Windows**
1. Di `/opt/teradata/tdat/tdgss/site` direktori, edit file`TdgssUserConfigFile.xml`. Ubah bagian LDAP menjadi yang berikut.
```
AuthorizationSupported="no"
LdapServerName="DC.test.local.com"
LdapServerPort="389"
LdapServerRealm="test.local.com"
LdapSystemFQDN="dc= test, dc= local, dc=com"
LdapBaseFQDN="dc=test, dc=local, dc=com"
```
1. Terapkan perubahan dengan menjalankan konfigurasi sebagai berikut.
```
#cd /opt/teradata/tdgss/bin
#./run_tdgssconfig
```
1. Uji konfigurasi dengan menjalankan perintah berikut.
```
# /opt/teradata/tdat/tdgss/14.10.03.01/bin/tdsbind -u test_ldap -w test_ldap
```
Output harus serupa dengan yang berikut ini.
```
LdapGroupBaseFQDN: dc=Test, dc=local, dc=com
LdapUserBaseFQDN: dc=Test, dc=local, dc=com
LdapSystemFQDN: dc= test, dc= local, dc=com
LdapServerName: DC.test.local.com
LdapServerPort: 389
LdapServerRealm: test.local.com
LdapClientUseTls: no
LdapClientTlsReqCert: never
LdapClientMechanism: SASL/DIGEST-MD5
LdapServiceBindRequired: no
LdapClientTlsCRLCheck: none
LdapAllowUnsafeServerConnect: yes
UseLdapConfig: no
AuthorizationSupported: no
FQDN: CN=test, CN=Users, DC=Anthem, DC=local, DC=com
AuthUser: ldap://DC.test.local.com:389/CN=test1,CN=Users,DC=test,DC=local,DC=com
DatabaseName: test
Service: tdsbind
```
1. Mulai ulang TPA menggunakan perintah berikut.
```
#tpareset -f "use updated TDGSSCONFIG GDO"
```
1. Buat pengguna yang sama di database Teradata seperti di Active Directory, seperti yang ditunjukkan berikut.
```
CREATE USER test_ldap AS PERM=1000, PASSWORD=test_ldap;
GRANT LOGON ON ALL TO test WITH NULL PASSWORD;
```
Jika Anda mengubah kata sandi pengguna di Active Directory untuk pengguna LDAP Anda, tentukan kata sandi baru ini selama koneksi ke Teradata dalam mode LDAP. Dalam mode DEFAULT, Anda terhubung ke Teradata dengan menggunakan nama pengguna LDAP dan kata sandi apa pun.
## Mengkonfigurasi pengumpulan statistik di gudang data Teradata sumber Anda
Untuk mengonversi gudang data Teradata sumber Anda, AWS SCT gunakan statistik untuk mengoptimalkan gudang data Amazon Redshift yang telah dikonversi. Anda dapat mengumpulkan statistik AWS SCT atau mengunggah file statistik. Untuk informasi selengkapnya, lihat [Mengumpulkan atau mengunggah statistik](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
Untuk memastikan bahwa AWS SCT dapat mengumpulkan statistik dari gudang data Anda, selesaikan tugas prasyarat berikut.
**Untuk mengumpulkan statistik dari gudang data Teradata Anda**
1. Jalankan kueri berikut untuk mengingat statistik untuk semua tabel di gudang data Anda.
```
collect summary statistics on table_name;
```
Pada contoh sebelumnya, ganti *table\$1name* dengan nama tabel sumber Anda. Ulangi kueri untuk setiap tabel yang Anda konversi.
1. Jalankan kueri berikut untuk menentukan string akun untuk pengguna, yang Anda gunakan untuk mengonversi gudang data Anda.
```
select * from dbc.accountinfo where username ='user_name'
```
1. Aktifkan pencatatan kueri untuk pengguna tertentu menggunakan string akun dari contoh sebelumnya.
```
BEGIN QUERY LOGGING WITH OBJECTS, SQL ON ALL ACCOUNT=('$M$BUSI$S$D$H');
```
Atau, aktifkan pencatatan kueri untuk semua pengguna database.
```
BEGIN QUERY LOGGING WITH SQL, OBJECTS LIMIT SQLTEXT=0 ON ALL;
```
Setelah Anda menyelesaikan pengumpulan statistik gudang data, matikan pencatatan kueri. Untuk melakukannya, Anda dapat menggunakan contoh kode berikut.
```
end query logging with explain, objects, sql on all account=(' $M$BUSI$S$D$H');
```
## Mengumpulkan statistik dalam mode offline dari gudang data Teradata sumber Anda
Setelah Anda mengonfigurasi pengumpulan statistik di gudang data Teradata Anda, Anda dapat mengumpulkan statistik dalam proyek Anda AWS SCT . Atau, Anda dapat menggunakan skrip Basic Teradata Query (BTEQ) untuk mengumpulkan statistik dalam mode offline. Kemudian, Anda dapat mengunggah file dengan statistik yang dikumpulkan ke AWS SCT proyek Anda. Untuk informasi selengkapnya, lihat [Mengumpulkan atau mengunggah statistik](CHAP_Converting.DW.md#CHAP_Converting.DW.Statistics).
**Untuk mengumpulkan statistik dari gudang data Teradata Anda dalam mode offline**
1. Buat `off-line_stats.bteq` skrip dengan konten berikut.
```
.OS IF EXIST column-stats-tera.csv del /F column-stats-tera.csv
.OS IF EXIST table-stats-tera.csv del /F table-stats-tera.csv
.OS IF EXIST column-skew-script-tera.csv del /F column-skew-script-tera.csv
.OS IF EXIST column-skew-stats-tera.csv del /F column-skew-stats-tera.csv
.OS IF EXIST query-stats-tera.csv del /F query-stats-tera.csv
.LOGON your_teradata_server/your_login, your_password
.EXPORT REPORT FILE = table-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
SELECT
'"' || OREPLACE(COALESCE(c.DatabaseName, ''), '"', '""') || '";' ||
'"' || OREPLACE(COALESCE(c.TableName, ''), '"', '""') || '";' ||
'"' || TRIM(COALESCE(s.reference_count, '0')) || '";' ||
'"' || TRIM(COALESCE(CAST(p.RowCount AS BIGINT), '0')) || '";' ||
'"' || CAST(CAST(w.size_in_mb AS DECIMAL (38,1) FORMAT 'Z9.9') AS VARCHAR(38)) || '";' ||
'"' || TRIM(COALESCE(r.stat_fk_dep_count, '0')) || '";' ||
'"' || CAST(CAST(current_timestamp(0) as timestamp(0) format 'YYYY-MM-DDBHH:MI:SS') as VARCHAR(19)) || '"'
(TITLE '"database_name";"table_name";"reference_count";"row_count";"size_in_mb";"stat_fk_dep_count";"current_ts"')
FROM (select databasename, tablename
from DBC.tablesv
where tablekind IN ('T','O')
and databasename = 'your_database_name'
) c
left join
(select DatabaseName, TableName, max(RowCount) RowCount
from dbc.tableStatsv
group by 1,2)p
on p.databasename = c.databasename
and p.tablename = c.tablename
left join
(SELECT r.ChildDB as DatabaseName,
r.ChildTable as TableName,
COUNT(DISTINCT r.ParentTable) reference_count
FROM DBC.All_RI_ChildrenV r
GROUP BY r.ChildDB, r.ChildTable) s
on s.databasename = c.databasename
and s.tablename = c.tablename
left join
(SELECT r.ParentDB as DatabaseName,
r.ParentTable as TableName,
COUNT(DISTINCT r.ChildTable) stat_fk_dep_count
FROM DBC.All_RI_ParentsV r
GROUP BY r.ParentDB, r.ParentTable) r
on r.databasename = c.databasename
and r.tablename = c.tablename
left join
(select databasename, tablename,
sum(currentperm)/1024/1024 as size_in_mb
from dbc.TableSizeV
group by 1,2) w
on w.databasename = c.databasename
and w.tablename = c.tablename
WHERE COALESCE(r.stat_fk_dep_count,0) + COALESCE(CAST(p.RowCount AS BIGINT),0) + COALESCE(s.reference_count,0) > 0;
.EXPORT RESET
.EXPORT REPORT FILE = column-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
'"' || TRIM(COALESCE(CAST(t2.card AS BIGINT), '0')) || '";' ||
SELECT
'"' || OREPLACE(COALESCE(trim(tv.DatabaseName), ''), '"', '""') || '";' ||
'"' || OREPLACE(COALESCE(trim(tv.TableName), ''), '"', '""') || '";' ||
'"' || OREPLACE(COALESCE(trim(tv.columnname), ''), '"', '""') || '";' ||
'"' || TRIM(COALESCE(CAST(t2.card AS BIGINT), '0')) || '";' ||
'"' || CAST(current_timestamp AS VARCHAR(19)) || '"' (TITLE '"database_name";"table_name";"column_name";"cardinality";"current_ts"')
FROM dbc.columnsv tv
LEFT JOIN
(
SELECT
c.DatabaseName AS DATABASE_NAME,
c.TABLENAME AS TABLE_NAME,
c.ColumnName AS COLUMN_NAME,
c.UniqueValueCount AS CARD
FROM dbc.tablestatsv c
WHERE c.DatabaseName = 'your_database_name'
AND c.RowCount <> 0
) t2
ON tv.DATABASENAME = t2.DATABASE_NAME
AND tv.TABLENAME = t2.TABLE_NAME
AND tv.COLUMNNAME = t2.COLUMN_NAME
WHERE t2.card > 0;
.EXPORT RESET
.EXPORT REPORT FILE = column-skew-script-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
SELECT
'SELECT CAST(''"' || TRIM(c.DatabaseName) || '";"' || TRIM(c.TABLENAME) || '";"' || TRIM(c.COLUMNNAME) || '";"'' ||
TRIM(CAST(COALESCE(MAX(cnt) * 1.0 / SUM(cnt), 0) AS NUMBER FORMAT ''9.9999'')) || ''";"'' ||
CAST(CURRENT_TIMESTAMP(0) AS VARCHAR(19)) || ''"'' AS VARCHAR(512))
AS """DATABASE_NAME"";""TABLE_NAME"";""COLUMN_NAME"";""SKEWED"";""CURRENT_TS"""
FROM(
SELECT COUNT(*) AS cnt
FROM "' || c.DATABASENAME || '"."' || c.TABLENAME ||
'" GROUP BY "' || c.COLUMNNAME || '") t' ||
CASE WHEN ROW_NUMBER() OVER(PARTITION BY c.DATABASENAME
ORDER BY c.TABLENAME DESC, c.COLUMNNAME DESC) <> 1
THEN ' UNION ALL'
ELSE ';' END (TITLE '--SKEWED--')
FROM dbc.columnsv c
INNER JOIN
(SELECT databasename, TABLENAME
FROM dbc.tablesv WHERE tablekind = 'T'
AND databasename = 'your_database_name') t
ON t.databasename = c.databasename
AND t.TABLENAME = c.TABLENAME
INNER JOIN
(SELECT databasename, TABLENAME, columnname FROM dbc.indices GROUP BY 1,2,3
WHERE TRANSLATE_CHK (databasename USING LATIN_TO_UNICODE) + TRANSLATE_CHK (TABLENAME USING LATIN_TO_UNICODE) + TRANSLATE_CHK (columnname USING LATIN_TO_UNICODE) = 0
) i
ON i.databasename = c.databasename
AND i.TABLENAME = c.TABLENAME
AND i.columnname = c.columnname
WHERE c.ColumnType NOT IN ('CO','JN','N','++','VA','UT','AN','XM','A1','BO')
ORDER BY c.TABLENAME, c.COLUMNNAME;
.EXPORT RESET
.EXPORT REPORT FILE = column-skew-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 10000
.RUN FILE = column-skew-script-tera.csv
.EXPORT RESET
.EXPORT REPORT FILE = query-stats-tera.csv
.SET TITLEDASHES OFF
.SET WIDTH 32000
SELECT
'"' || RTRIM(CAST(SqlTextInfo AS VARCHAR(31900)), ';') || '";"' ||
TRIM(QueryCount) || '";"' ||
TRIM(QueryId) || '";"' ||
TRIM(SqlRowNo) || '";"' ||
TRIM(QueryParts) || '";"' ||
CAST(CURRENT_TIMESTAMP(0) AS VARCHAR(19)) || '"'
(TITLE '"query_text";"query_count";"query_id";"sql_row_no";"query_parts";"current_ts"')
FROM
(
SELECT QueryId, SqlTextInfo, SqlRowNo, QueryParts, QueryCount,
SUM(QueryFirstRow) OVER (ORDER BY QueryCount DESC, QueryId ASC, SqlRowNo ASC
ROWS UNBOUNDED PRECEDING) AS topN
FROM
(SELECT QueryId, SqlTextInfo, SqlRowNo, QueryParts, QueryCount,
CASE WHEN
ROW_NUMBER() OVER (PARTITION BY QueryCount, SqlTextInfo ORDER BY QueryId, SqlRowNo) = 1 AND SqlRowNo = 1
THEN 1 ELSE 0 END AS QueryFirstRow
FROM (
SELECT q.QueryId, q.SqlTextInfo, q.SqlRowNo,
MAX(q.SqlRowNo) OVER (PARTITION BY q.QueryId) QueryParts,
COUNT(q.SqlTextInfo) OVER (PARTITION BY q.SqlTextInfo) QueryCount
FROM DBC.dbqlsqltbl q
INNER JOIN
(
SELECT QueryId
FROM DBC.DBQLogTbl t
WHERE TRIM(t.StatementType) IN ('SELECT')
AND TRIM(t.AbortFlag) = '' AND t.ERRORCODE = 0
AND (CASE WHEN 'All users' IN ('All users') THEN 'All users' ELSE TRIM(t.USERNAME) END) IN ('All users') --user_name list
AND t.StartTime > CURRENT_TIMESTAMP - INTERVAL '30' DAY
GROUP BY 1
) t
ON q.QueryId = t.QueryId
INNER JOIN
(
SELECT QueryId
FROM DBC.QryLogObjectsV
WHERE ObjectDatabaseName = 'your_database_name'
AND ObjectType = 'Tab'
AND CollectTimeStamp > CURRENT_TIMESTAMP - INTERVAL '30' DAY
GROUP BY 1
) r
ON r.QueryId = t.QueryId
WHERE q.CollectTimeStamp > CURRENT_TIMESTAMP - INTERVAL '30' DAY
) t
) t
WHERE SqlTextInfo NOT LIKE '%";"%'
) q
WHERE
QueryParts >=1
AND topN <= 50
ORDER BY QueryCount DESC, QueryId, SqlRowNo
QUALIFY COUNT(QueryId) OVER (PARTITION BY QueryId) = QueryParts;
.EXPORT RESET
.LOGOFF
.QUIT
```
1. Buat `td_run_bteq.bat` file yang menjalankan skrip BTEQ yang Anda buat pada langkah sebelumnya. Gunakan konten berikut untuk file ini.
```
@echo off > off-line_stats1.bteq & setLocal enableDELAYedexpansion
@echo off > off-line_stats2.bteq & setLocal enableDELAYedexpansion
set old1=your_teradata_server
set new1=%1
set old2=your_login
set new2=%2
set old3=your_database_name
set new3=%3
set old4=your_password
set /p new4=Input %2 pass?
for /f "tokens=* delims= " %%a in (off-line_stats.bteq) do (
set str1=%%a
set str1=!str1:%old1%=%new1%!
>> off-line_stats1.bteq echo !str1!
)
for /f "tokens=* delims= " %%a in (off-line_stats1.bteq) do (
set str2=%%a
set str2=!str2:%old2%=%new2%!
>> off-line_stats2.bteq echo !str2!
)
type nul > off-line_stats1.bteq
for /f "tokens=* delims= " %%a in (off-line_stats2.bteq) do (
set str3=%%a
set str3=!str3:%old3%=%new3%!
>> off-line_stats1.bteq echo !str3!
)
type nul > off-line_stats2.bteq
for /f "tokens=* delims= " %%a in (off-line_stats1.bteq) do (
set str4=%%a
set str4=!str4:%old4%=%new4%!
>> off-line_stats2.bteq echo !str4!
)
del .\off-line_stats1.bteq
echo export starting...
bteq -c UTF8 < off-line_stats.bteq > metadata_export.log
pause
```
1. Buat `runme.bat` file yang menjalankan file batch yang Anda buat di langkah sebelumnya. Gunakan konten berikut untuk file ini.
```
.\td_run_bteq.bat ServerName UserName DatabaseName
```
Dalam `runme.bat` file, ganti*ServerName*,*UserName*, dan *DatabaseName* dengan nilai yang berlaku.
Kemudian, jalankan `runme.bat` file tersebut. Ulangi langkah ini untuk setiap gudang data yang Anda konversi ke Amazon Redshift.
Setelah Anda menjalankan skrip ini, Anda menerima tiga file dengan statistik untuk setiap database. Anda dapat mengunggah file-file ini ke AWS SCT proyek Anda. Untuk melakukannya, pilih gudang data Anda dari panel kiri proyek Anda, dan buka menu konteks (klik kanan). Pilih **Unggah Statistik**.
## Pengaturan konversi Teradata ke Amazon Redshift
**Untuk mengedit pengaturan konversi Teradata ke Amazon Redshift, **pilih Pengaturan AWS SCT di, lalu pilih** Pengaturan konversi.** Dari daftar atas, pilih **Teradata**, lalu pilih **Teradata — Amazon** Redshift. AWS SCT menampilkan semua pengaturan yang tersedia untuk konversi Teradata ke Amazon Redshift.
Pengaturan konversi Teradata ke Amazon Redshift AWS SCT di menyertakan opsi untuk hal berikut:
+ Untuk membatasi jumlah komentar dengan item tindakan dalam kode yang dikonversi.
Untuk **Tambahkan komentar di kode yang dikonversi untuk item tindakan dengan tingkat keparahan yang dipilih dan lebih tinggi**, pilih tingkat keparahan item tindakan. AWS SCT menambahkan komentar dalam kode yang dikonversi untuk item tindakan dengan tingkat keparahan yang dipilih dan lebih tinggi.
Misalnya, untuk meminimalkan jumlah komentar dalam kode yang dikonversi, pilih **Error only**. Untuk menyertakan komentar untuk semua item tindakan dalam kode yang dikonversi, pilih **Semua pesan**.
+ Untuk mengatur jumlah maksimum tabel yang AWS SCT dapat diterapkan ke cluster Amazon Redshift target Anda.
Untuk **Jumlah maksimum tabel untuk klaster Amazon Redshift target, pilih jumlah tabel yang AWS SCT dapat diterapkan ke cluster** Amazon Redshift Anda.
Amazon Redshift memiliki kuota yang membatasi tabel penggunaan untuk jenis node cluster yang berbeda. Jika Anda memilih **Otomatis**, AWS SCT tentukan jumlah tabel yang akan diterapkan ke klaster Amazon Redshift target Anda tergantung pada jenis node. Secara opsional, pilih nilai secara manual. Untuk informasi selengkapnya, lihat [Kuota dan batasan di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) dalam *Panduan Manajemen Amazon Redshift*.
AWS SCT mengonversi semua tabel sumber Anda, meskipun ini lebih dari yang dapat disimpan oleh cluster Amazon Redshift Anda. AWS SCT menyimpan kode yang dikonversi dalam proyek Anda dan tidak menerapkannya ke database target. Jika Anda mencapai kuota klaster Amazon Redshift untuk tabel saat menerapkan kode yang dikonversi, maka akan AWS SCT menampilkan pesan peringatan. Selain itu, AWS SCT terapkan tabel ke cluster Amazon Redshift target Anda hingga jumlah tabel mencapai batas.
+ Untuk memigrasikan partisi tabel sumber ke tabel terpisah di Amazon Redshift. Untuk melakukannya, pilih **Gunakan tampilan UNION ALL** dan masukkan jumlah maksimum tabel target yang AWS SCT dapat dibuat untuk tabel sumber tunggal.
Amazon Redshift tidak mendukung partisi tabel. Untuk meniru perilaku ini dan membuat kueri berjalan lebih cepat, AWS SCT dapat memigrasikan setiap partisi tabel sumber Anda ke tabel terpisah di Amazon Redshift. Kemudian, AWS SCT buat tampilan yang menyertakan data dari semua tabel ini.
AWS SCT secara otomatis menentukan jumlah partisi dalam tabel sumber Anda. Bergantung pada jenis partisi tabel sumber, angka ini dapat melebihi kuota untuk tabel yang dapat Anda terapkan ke cluster Amazon Redshift Anda. Untuk menghindari mencapai kuota ini, masukkan jumlah maksimum tabel target yang AWS SCT dapat dibuat untuk partisi dari tabel sumber tunggal. Opsi default adalah 368 tabel, yang mewakili partisi selama 366 hari dalam setahun dan dua tabel untuk `NO RANGE` dan `UNKNOWN` partisi.
+ Untuk menerapkan kompresi ke kolom tabel Amazon Redshift. Untuk melakukannya, pilih **Gunakan pengkodean kompresi**.
AWS SCT menetapkan pengkodean kompresi ke kolom secara otomatis menggunakan algoritme Amazon Redshift default. Untuk informasi selengkapnya, lihat [Pengkodean kompresi di Panduan](https://docs.aws.amazon.com/redshift/latest/dg/c_Compression_encodings.html) Pengembang *Database Amazon Redshift*.
Secara default, Amazon Redshift tidak menerapkan kompresi ke kolom yang didefinisikan sebagai kunci pengurutan dan distribusi. Anda dapat mengubah perilaku ini dan menerapkan kompresi ke kolom ini. Untuk melakukannya, pilih **Gunakan pengkodean kompresi untuk kolom KEY**. Anda dapat memilih opsi ini hanya ketika Anda memilih opsi **Gunakan pengkodean kompresi**.
+ Untuk menggunakan daftar kolom eksplisit dalam kode yang dikonversi untuk `SELECT *` pernyataan, pilih **Gunakan deklarasi kolom eksplisit**.
+ Untuk meniru perilaku kunci primer dan unik di klaster Amazon Redshift Anda, **pilih Emulasikan perilaku kunci primer dan** unik.
Amazon Redshift tidak menerapkan kunci unik dan utama dan menggunakannya hanya untuk tujuan informasi. Jika Anda menggunakan batasan ini dalam kode Anda, maka pastikan itu AWS SCT mengemulasi perilaku mereka dalam kode yang dikonversi.
+ Untuk memastikan keunikan data dalam tabel Amazon Redshift target. Untuk melakukannya, pilih **Emulasikan perilaku tabel SET**.
Teradata membuat tabel menggunakan elemen `SET` sintaks sebagai opsi default. Anda tidak dapat menambahkan baris duplikat dalam `SET` tabel. Jika kode sumber Anda tidak menggunakan kendala keunikan ini, matikan opsi ini. Dalam hal ini, kode yang dikonversi bekerja lebih cepat.
Jika kode sumber Anda menggunakan `SET` opsi dalam tabel sebagai kendala keunikan, aktifkan opsi ini. Dalam hal ini, AWS SCT menulis ulang `INSERT..SELECT` pernyataan dalam kode yang dikonversi untuk meniru perilaku database sumber Anda.
## Pengaturan pengoptimalan konversi Teradata ke Amazon Redshift
**Untuk mengedit pengaturan pengoptimalan konversi Teradata ke Amazon Redshift, **pilih** Pengaturan AWS SCT di, lalu pilih Pengaturan konversi.** Dari daftar atas, pilih **Teradata**, lalu pilih **Teradata — Amazon** Redshift. Di panel kiri, pilih **Strategi optimasi**. AWS SCT menampilkan pengaturan pengoptimalan konversi untuk konversi Teradata ke Amazon Redshift.
Pengaturan pengoptimalan konversi Teradata ke Amazon Redshift AWS SCT di menyertakan opsi untuk hal berikut:
+ Untuk bekerja dengan optimasi tabel otomatis. Untuk melakukannya, pilih **Gunakan penyetelan tabel otomatis Amazon Redshift**.
Optimalisasi tabel otomatis adalah proses self-tuning di Amazon Redshift yang secara otomatis mengoptimalkan desain tabel. Untuk informasi selengkapnya, lihat [Bekerja dengan pengoptimalan tabel otomatis](https://docs.aws.amazon.com/redshift/latest/dg/t_Creating_tables.html) di Panduan *Pengembang Database Amazon Redshift*.
Untuk hanya mengandalkan optimasi tabel otomatis, pilih **None** for **Initial key selection strategy**.
+ Untuk memilih kunci sortir dan distribusi menggunakan strategi Anda.
Anda dapat memilih kunci sortir dan distribusi menggunakan metadata Amazon Redshift, informasi statistik, atau kedua opsi ini. Untuk **strategi pemilihan kunci awal** pada tab **Strategi optimasi**, pilih salah satu opsi berikut:
+ Gunakan metadata, abaikan informasi statistik
+ Abaikan metadata, gunakan informasi statistik
+ Gunakan metadata dan informasi statistik
Bergantung pada opsi yang Anda pilih, Anda dapat memilih strategi pengoptimalan. Kemudian, untuk setiap strategi, masukkan nilainya (0-100). Nilai-nilai ini menentukan bobot setiap strategi. Dengan menggunakan nilai bobot ini, AWS SCT mendefinisikan bagaimana setiap aturan mempengaruhi pilihan distribusi dan kunci pengurutan. Nilai default didasarkan pada praktik terbaik AWS migrasi.
Anda dapat menentukan ukuran tabel kecil untuk strategi **Temukan tabel kecil**. Untuk **jumlah baris tabel Min** dan **jumlah baris tabel Maks**, masukkan jumlah baris minimum dan maksimum dalam tabel untuk mendefinisikannya sebagai tabel kecil. AWS SCT menerapkan gaya `ALL` distribusi ke tabel kecil. Dalam hal ini, salinan seluruh tabel didistribusikan ke setiap node.
+ Untuk mengkonfigurasi detail strategi.
Selain menentukan bobot untuk setiap strategi pengoptimalan, Anda dapat mengonfigurasi pengaturan pengoptimalan. Untuk melakukannya, pilih **Optimasi konversi**.
+ Untuk **Batas kolom kunci Urutkan**, masukkan jumlah kolom maksimum di tombol sortir.
+ Untuk **nilai ambang miring**, masukkan persentase (0-100) dari nilai miring untuk kolom. AWS SCT mengecualikan kolom dengan nilai miring lebih besar dari ambang batas dari daftar kandidat untuk kunci distribusi. AWS SCT mendefinisikan nilai miring untuk kolom sebagai rasio persentase dari jumlah kemunculan nilai yang paling umum dengan jumlah total catatan.
+ Untuk **kueri N Teratas dari tabel riwayat kueri**, masukkan nomor (1-100) kueri yang paling sering digunakan untuk dianalisis.
+ Untuk **Pilih pengguna statistik**, pilih pengguna database yang ingin Anda analisis statistik kueri.
Juga, pada tab **Strategi optimasi**, Anda dapat menentukan ukuran tabel kecil untuk strategi **Temukan tabel kecil**. Untuk **jumlah baris tabel Min** dan **Jumlah baris tabel Maks**, masukkan jumlah baris minimum dan maksimum dalam tabel untuk menganggapnya sebagai tabel kecil. AWS SCT menerapkan gaya `ALL` distribusi ke tabel kecil. Dalam hal ini, salinan seluruh tabel didistribusikan ke setiap node.