Amazon Redshift tidak akan lagi mendukung pembuatan Python UDFs baru mulai Patch 198. Python yang ada UDFs akan terus berfungsi hingga 30 Juni 2026. Untuk informasi lebih lanjut, lihat [posting blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memuat data di Amazon Redshift
Ada beberapa cara untuk memuat data ke dalam database Amazon Redshift. Salah satu sumber data yang populer untuk dimuat adalah file Amazon S3. Tabel berikut merangkum beberapa metode yang akan digunakan mulai dari sumber Amazon S3.
| Metode untuk menggunakan | Deskripsi | Ketika metode yang dibutuhkan |
| --- | --- | --- |
| Perintah SALIN | Menjalankan konsumsi file batch untuk memuat data dari file Amazon S3 Anda. Metode ini memanfaatkan kemampuan pemrosesan paralel Amazon Redshift. Untuk informasi selengkapnya, lihat [Memuat tabel dengan perintah COPY](t_Loading_tables_with_the_COPY_command.md). | Harus digunakan ketika persyaratan pemuatan data dasar untuk memulai konsumsi file batch secara manual diperlukan. Metode ini sebagian besar digunakan dengan pipeline konsumsi file kustom dan pihak ketiga atau beban kerja konsumsi file satu kali, atau ad hoc. |
| SALIN... CREATE JOB perintah (auto-copy) | Menjalankan perintah COPY Anda secara otomatis saat file baru dibuat di jalur Amazon S3 yang dilacak. Untuk informasi selengkapnya, lihat [Buat integrasi acara S3 untuk menyalin file secara otomatis dari bucket Amazon S3](loading-data-copy-job.md). | Harus digunakan saat pipeline konsumsi file perlu secara otomatis menyerap data saat file baru dibuat di Amazon S3. Amazon Redshift melacak file yang tertelan untuk mencegah duplikasi data. Metode ini memerlukan konfigurasi oleh pemilik bucket Amazon S3. |
| Muat dari kueri data lake | Buat tabel eksternal untuk menjalankan kueri data lake pada file Amazon S3 Anda dan kemudian jalankan perintah INSERT INTO untuk memuat hasil dari kueri data lake Anda ke tabel lokal. Untuk informasi selengkapnya, lihat [Tabel eksternal untuk Redshift Spectrum](c-spectrum-external-tables.md). | Harus digunakan dalam salah satu skenario berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/t_Loading_data.html) |
| Metode lain yang dapat Anda pertimbangkan |
| Streaming konsumsi | Penyerapan streaming menyediakan konsumsi data streaming berkecepatan tinggi dengan latensi rendah dan berkecepatan tinggi dari Amazon Kinesis Data Streams dan Amazon Managed Streaming untuk Apache Kafka Kafka ke tampilan terwujud Amazon Redshift atau Redshift Tanpa Server. Untuk informasi selengkapnya, lihat [Memulai dengan konsumsi streaming dari Amazon Kinesis Data Streams](materialized-view-streaming-ingestion-getting-started.md) dan [Memulai dengan konsumsi streaming dari sumber Apache Kafka](materialized-view-streaming-ingestion-getting-started-MSK.md). | Harus dipertimbangkan untuk kasus penggunaan ketika data pertama kali dialirkan ke file di Amazon S3 dan kemudian dimuat dari Amazon S3. Jika menyimpan data di Amazon S3 tidak diperlukan, Anda sering dapat mempertimbangkan streaming data Anda langsung ke Amazon Redshift. |
| Menjalankan kueri data lake | Menjalankan kueri langsung dari tabel data lake alih-alih menelan isi tabel ke dalam tabel lokal. Untuk informasi selengkapnya, lihat [Amazon Redshift Spectrum](c-using-spectrum.md). | Harus digunakan ketika kasus penggunaan tidak memerlukan kinerja kueri tabel lokal di Amazon Redshift. |
| Pemuatan batch menggunakan editor kueri Amazon Redshift v2 | Anda dapat menyiapkan dan menjalankan beban kerja penyerapan file batch secara visual di editor kueri Amazon Redshift v2. Untuk informasi selengkapnya, lihat [Memuat data dari S3](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-loading.html#query-editor-v2-loading-data) di Panduan *Manajemen Amazon Redshift*. | Harus digunakan ketika Anda ingin editor kueri v2 untuk menyiapkan pernyataan COPY dan Anda ingin alat visual untuk menyederhanakan proses persiapan pernyataan COPY. |
| Memuat data dari file lokal menggunakan editor kueri Amazon Redshift v2 | Anda dapat langsung mengunggah file dari desktop Anda ke tabel Amazon Redshift tanpa perlu mengunggah file Anda secara manual ke Amazon S3. Untuk informasi selengkapnya, lihat [Memuat data dari penyiapan dan alur kerja file lokal](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-loading.html#query-editor-v2-loading-data-local) di Panduan *Manajemen Amazon Redshift*. | Harus digunakan ketika Anda perlu memuat file dengan cepat dari komputer lokal Anda untuk tujuan kueri satu kali. Dengan metode ini, editor kueri Amazon Redshift v2 untuk sementara menyimpan file di bucket Amazon S3 milik pelanggan dan menjalankan perintah salin menggunakan jalur Amazon S3 ini. |
Perintah COPY adalah cara paling efisien untuk memuat tabel. Anda juga dapat menambahkan data ke tabel Anda menggunakan perintah INSERT, meskipun jauh lebih efisien daripada menggunakan COPY. Perintah COPY dapat membaca dari beberapa file data atau beberapa aliran data secara bersamaan. Amazon Redshift mengalokasikan beban kerja ke node Amazon Redshift dan melakukan operasi pemuatan secara paralel, termasuk menyortir baris dan mendistribusikan data di seluruh irisan node.
**catatan**
Tabel eksternal Amazon Redshift Spectrum hanya bisa dibaca. Anda tidak dapat COPY atau INSERT ke tabel eksternal.
Untuk mengakses data pada AWS sumber daya lain, Amazon Redshift harus memiliki izin untuk mengakses sumber daya tersebut dan untuk melakukan tindakan yang diperlukan untuk mengakses data. Anda dapat menggunakan AWS Identity and Access Management (IAM) untuk membatasi akses yang dimiliki pengguna ke sumber daya dan data Amazon Redshift.
Setelah data awal Anda dimuat, jika Anda menambahkan, memodifikasi, atau menghapus sejumlah besar data, Anda harus menindaklanjuti dengan menjalankan perintah VACUUM untuk mengatur ulang data Anda dan merebut kembali ruang setelah dihapus. Anda juga harus menjalankan perintah ANALYZE untuk memperbarui statistik tabel.
**Topics**
+ [Memuat tabel dengan perintah COPY](t_Loading_tables_with_the_COPY_command.md)
+ [Buat integrasi acara S3 untuk menyalin file secara otomatis dari bucket Amazon S3](loading-data-copy-job.md)
+ [Memuat tabel dengan perintah DML](t_Updating_tables_with_DML_commands.md)
+ [Melakukan salinan yang dalam](performing-a-deep-copy.md)
+ [Menganalisis tabel](t_Analyzing_tables.md)
+ [Tabel penyedot debu](t_Reclaiming_storage_space202.md)
+ [Mengelola operasi tulis bersamaan](c_Concurrent_writes.md)
+ [Tutorial: Memuat data dari Amazon S3](tutorial-loading-data.md)
# Memuat tabel dengan perintah COPY
Perintah COPY memanfaatkan arsitektur Amazon Redshift massively parallel processing (MPP) untuk membaca dan memuat data secara paralel dari file di Amazon S3, dari tabel DynamoDB, atau dari output teks dari satu atau beberapa host jarak jauh.
Sebelum mempelajari semua opsi perintah COPY, kami sarankan mempelajari opsi dasar untuk memuat data Amazon S3. *Panduan Memulai Amazon Redshift* menunjukkan penggunaan sederhana perintah COPY untuk memuat data Amazon S3 menggunakan peran IAM default. Lihat [Langkah 4: Muat data dari Amazon S3 ke Amazon Redshift untuk detailnya](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html).
**catatan**
Kami sangat menyarankan menggunakan perintah COPY untuk memuat sejumlah besar data. Menggunakan pernyataan INSERT individu untuk mengisi tabel mungkin sangat lambat. Atau, jika data Anda sudah ada di tabel database Amazon Redshift lainnya, gunakan INSERT INTO... PILIH atau BUAT TABEL AS untuk meningkatkan kinerja. Untuk informasi, lihat [INSERT](r_INSERT_30.md) atau[CREATE TABLE AS](r_CREATE_TABLE_AS.md).
Untuk memuat data dari AWS sumber daya lain, Amazon Redshift harus memiliki izin untuk mengakses sumber daya dan melakukan tindakan yang diperlukan.
Untuk memberikan atau mencabut hak istimewa untuk memuat data ke dalam tabel menggunakan perintah COPY, berikan atau cabut hak istimewa INSERT.
Data Anda harus dalam format yang tepat untuk dimuat ke tabel Amazon Redshift Anda. Bagian ini menyajikan panduan untuk mempersiapkan dan memverifikasi data Anda sebelum memuat dan untuk memvalidasi pernyataan COPY sebelum Anda menjalankannya.
Untuk melindungi informasi dalam file Anda, Anda dapat mengenkripsi file data sebelum mengunggahnya ke bucket Amazon S3 Anda; COPY akan mendekripsi data saat melakukan pemuatan. Anda juga dapat membatasi akses ke data pemuatan Anda dengan memberikan kredensil keamanan sementara kepada pengguna. Kredensi keamanan sementara memberikan keamanan yang ditingkatkan karena mereka memiliki rentang hidup yang pendek dan tidak dapat digunakan kembali setelah kedaluwarsa.
Amazon Redshift memiliki fitur bawaan untuk COPY untuk memuat data yang tidak terkompresi dan dibatasi dengan cepat. Tetapi Anda dapat mengompres file Anda menggunakan gzip, lzop, atau bzip2 untuk menghemat waktu mengunggah file.
Jika kata kunci berikut ada dalam kueri COPY, pemisahan otomatis data yang tidak terkompresi tidak didukung: ESCAPE, REMOVEQUOTES, dan FIXEDWIDTH. Tetapi kata kunci CSV didukung.
Untuk membantu menjaga keamanan data Anda saat transit di dalam AWS Cloud, Amazon Redshift menggunakan SSL yang dipercepat perangkat keras untuk berkomunikasi dengan Amazon S3 atau Amazon DynamoDB untuk operasi COPY, UNLOAD, backup, dan restore.
Saat memuat tabel langsung dari tabel Amazon DynamoDB, Anda memiliki opsi untuk mengontrol jumlah throughput yang disediakan Amazon DynamoDB yang Anda konsumsi.
Anda dapat secara opsional membiarkan COPY menganalisis data input Anda dan secara otomatis menerapkan pengkodean kompresi optimal ke tabel Anda sebagai bagian dari proses pemuatan.
**Topics**
+ [Kredensyal dan izin akses](loading-data-access-permissions.md)
+ [Mempersiapkan data masukan Anda](t_preparing-input-data.md)
+ [Memuat data dari Amazon S3](t_Loading-data-from-S3.md)
+ [Memuat data dari Amazon EMR](loading-data-from-emr.md)
+ [Memuat data dari host jarak jauh](loading-data-from-remote-hosts.md)
+ [Memuat data dari tabel Amazon DynamoDB](t_Loading-data-from-dynamodb.md)
+ [Memverifikasi bahwa data dimuat dengan benar](verifying-that-data-loaded-correctly.md)
+ [Memvalidasi data masukan](t_Validating_input_files.md)
+ [Memuat tabel dengan kompresi otomatis](c_Loading_tables_auto_compress.md)
+ [Mengoptimalkan penyimpanan untuk tabel sempit](c_load_compression_hidden_cols.md)
+ [Memuat nilai kolom default](c_loading_default_values.md)
+ [Memecahkan masalah beban data](t_Troubleshooting_load_errors.md)
# Kredensyal dan izin akses
Untuk memuat atau membongkar data menggunakan AWS sumber daya lain, seperti Amazon S3, Amazon DynamoDB, Amazon EMR, atau Amazon EC2, Amazon Redshift harus memiliki izin untuk mengakses sumber daya dan melakukan tindakan yang diperlukan untuk mengakses data. Misalnya, untuk memuat data dari Amazon S3, COPY harus memiliki akses LIST ke bucket dan GET access untuk objek bucket.
Untuk mendapatkan otorisasi untuk mengakses sumber daya, Amazon Redshift harus diautentikasi. Anda dapat memilih kontrol akses berbasis peran atau kontrol akses berbasis kunci. Bagian ini menyajikan ikhtisar dari dua metode. Untuk detail dan contoh selengkapnya, lihat[Izin untuk mengakses Sumber Daya lainnya AWS](copy-usage_notes-access-permissions.md).
## Kontrol akses berbasis peran
Dengan kontrol akses berbasis peran, Amazon Redshift untuk sementara mengambil peran AWS Identity and Access Management (IAM) atas nama Anda. Kemudian, berdasarkan otorisasi yang diberikan untuk peran tersebut, Amazon Redshift dapat mengakses sumber daya yang AWS diperlukan.
Sebaiknya gunakan kontrol akses berbasis peran karena memberikan kontrol akses yang lebih aman dan halus terhadap AWS sumber daya dan data pengguna yang sensitif, selain melindungi kredensyal Anda. AWS
Untuk menggunakan kontrol akses berbasis peran, Anda harus terlebih dahulu membuat peran IAM menggunakan jenis peran layanan Amazon Redshift, lalu lampirkan peran tersebut ke gudang data Anda. Peran harus memiliki, setidaknya, izin yang tercantum dalam[Izin IAM untuk COPY, UNLOAD, dan CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions). Untuk langkah-langkah untuk membuat peran IAM dan melampirkannya ke cluster Anda, lihat [Membuat Peran IAM untuk Mengizinkan Cluster Amazon Redshift Anda AWS Mengakses Layanan di Panduan](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html#authorizing-redshift-service-creating-an-iam-role) Manajemen Amazon *Redshift*.
Anda dapat menambahkan peran ke klaster atau melihat peran yang terkait dengan klaster menggunakan Amazon Redshift Management Console, CLI, atau API. Untuk informasi selengkapnya, lihat [Mengotorisasi Operasi COPY dan UNLOAD Menggunakan Peran IAM](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html) di Panduan Manajemen *Amazon* Redshift.
Saat Anda membuat peran IAM, IAM mengembalikan Amazon Resource Name (ARN) untuk peran tersebut. Untuk menjalankan perintah COPY menggunakan peran IAM, berikan peran ARN menggunakan parameter IAM\$1ROLE atau parameter CREDENTIALS.
Contoh perintah COPY berikut menggunakan parameter IAM\$1ROLE dengan peran untuk otentikasi. `MyRedshiftRole`
```
COPY customer FROM 's3://amzn-s3-demo-bucket/mydata'
IAM_ROLE 'arn:aws:iam::12345678901:role/MyRedshiftRole';
```
AWS Pengguna harus memiliki, setidaknya, izin yang tercantum dalam[Izin IAM untuk COPY, UNLOAD, dan CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions).
## Kontrol akses berbasis kunci
Dengan kontrol akses berbasis kunci, Anda memberikan ID kunci akses dan kunci akses rahasia untuk pengguna yang berwenang untuk mengakses AWS sumber daya yang berisi data.
**catatan**
Kami sangat menyarankan menggunakan peran IAM untuk otentikasi daripada menyediakan ID kunci akses teks biasa dan kunci akses rahasia. Jika Anda memilih kontrol akses berbasis kunci, jangan pernah menggunakan kredensi AWS akun (root) Anda. Selalu buat pengguna IAM dan berikan ID kunci akses dan kunci akses rahasia pengguna tersebut. Untuk langkah-langkah untuk membuat pengguna IAM, lihat [Membuat Pengguna IAM di Akun Anda AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html).
# Mempersiapkan data masukan Anda
Jika data input Anda tidak kompatibel dengan kolom tabel yang akan menerimanya, perintah COPY akan gagal.
Gunakan panduan berikut untuk membantu memastikan bahwa data masukan Anda valid:
+ Data Anda hanya dapat berisi karakter UTF-8 hingga empat byte.
+ Verifikasi bahwa string CHAR dan VARCHAR tidak lebih dari panjang kolom yang sesuai. String VARCHAR diukur dalam byte, bukan karakter, jadi, misalnya, string empat karakter karakter karakter Mandarin yang masing-masing menempati empat byte memerlukan kolom VARCHAR (16).
+ Karakter multibyte hanya dapat digunakan dengan kolom VARCHAR. Verifikasi bahwa karakter multibyte tidak lebih dari empat byte panjangnya.
+ Verifikasi bahwa data untuk kolom CHAR hanya berisi karakter byte tunggal.
+ Jangan sertakan karakter atau sintaks khusus untuk menunjukkan bidang terakhir dalam catatan. Bidang ini bisa menjadi pembatas.
+ Jika data Anda menyertakan terminator null, juga disebut NUL (UTF-8 0000) atau biner nol (0x000), Anda dapat memuat karakter ini sebagai NULLS ke kolom CHAR atau VARCHAR dengan menggunakan opsi NULL AS dalam perintah COPY: atau. `null as '\0'` `null as '\000'` Jika Anda tidak menggunakan NULL AS, terminator null akan menyebabkan COPY Anda gagal.
+ Jika string Anda berisi karakter khusus, seperti pembatas dan baris baru yang disematkan, gunakan opsi ESCAPE dengan perintah. [MENYONTEK](r_COPY.md)
+ Verifikasi bahwa semua tanda kutip tunggal dan ganda cocok dengan tepat.
+ Verifikasi bahwa string floating-point berada dalam format floating-point standar, seperti 12.123, atau format eksponensial, seperti 1.0E4.
+ Verifikasi bahwa semua stempel waktu dan string tanggal mengikuti spesifikasi untuk. [string DATEFORMAT dan TIMEFORMATContoh](r_DATEFORMAT_and_TIMEFORMAT_strings.md) Format stempel waktu default adalah YYYY-MM-DD hh:mm:ss, dan format tanggal defaultnya adalah. YYYY-MM-DD
+ Untuk informasi selengkapnya tentang batasan dan batasan pada tipe data individual, lihat[Jenis Data](c_Supported_data_types.md). Untuk informasi tentang kesalahan karakter multibyte, lihat [Kesalahan pemuatan karakter multibyte](multi-byte-character-load-errors.md)
# Memuat data dari Amazon S3
Perintah COPY memanfaatkan arsitektur Amazon Redshift massively parallel processing (MPP) untuk membaca dan memuat data secara paralel dari file atau beberapa file dalam bucket Amazon S3. Anda dapat mengambil keuntungan maksimal dari pemrosesan paralel dengan membagi data Anda menjadi beberapa file, dalam kasus di mana file dikompresi. (Ada pengecualian untuk aturan ini. Ini dirinci dalam [Memuat file data](https://docs.aws.amazon.com/redshift/latest/dg/c_best-practices-use-multiple-files.html).) Anda juga dapat mengambil keuntungan maksimal dari pemrosesan paralel dengan mengatur kunci distribusi pada tabel Anda. Untuk informasi selengkapnya tentang kunci distribusi, lihat[Distribusi data untuk optimasi kueri](t_Distributing_data.md).
Data dimuat ke dalam tabel target, satu baris per baris. Bidang dalam file data dicocokkan dengan kolom tabel secara berurutan, kiri ke kanan. Bidang dalam file data dapat dengan lebar tetap atau dibatasi karakter; pembatas default adalah pipa (\$1). Secara default, semua kolom tabel dimuat, tetapi Anda dapat secara opsional menentukan daftar kolom yang dipisahkan koma. Jika kolom tabel tidak termasuk dalam daftar kolom yang ditentukan dalam perintah COPY, itu dimuat dengan nilai default. Untuk informasi selengkapnya, lihat [Memuat nilai kolom default](c_loading_default_values.md).
**Topics**
+ [Memuat data dari file terkompresi dan tidak terkompresi](t_splitting-data-files.md)
+ [Mengunggah file ke Amazon S3 untuk digunakan dengan COPY](t_uploading-data-to-S3.md)
+ [Menggunakan perintah COPY untuk memuat dari Amazon S3](t_loading-tables-from-s3.md)
# Memuat data dari file terkompresi dan tidak terkompresi
Saat memuat data terkompresi, sebaiknya Anda membagi data untuk setiap tabel menjadi beberapa file. Saat Anda memuat data yang tidak terkompresi dan dibatasi, perintah COPY menggunakan pemrosesan paralel masif (MPP) dan rentang pemindaian untuk memuat data dari file besar di bucket Amazon S3.
## Memuat data dari beberapa file terkompresi
Dalam kasus di mana Anda memiliki data terkompresi, kami sarankan Anda membagi data untuk setiap tabel menjadi beberapa file. Perintah COPY dapat memuat data dari beberapa file secara paralel. Anda dapat memuat beberapa file dengan menentukan awalan umum, atau *kunci awalan*, untuk set, atau dengan secara eksplisit mencantumkan file dalam file manifes.
Pisahkan data Anda menjadi file sehingga jumlah file adalah kelipatan dari jumlah irisan di cluster Anda. Dengan begitu, Amazon Redshift dapat membagi data secara merata di antara irisan. Jumlah irisan per node tergantung pada ukuran node cluster. Misalnya, setiap node komputasi dc2.large memiliki dua irisan, dan setiap node komputasi dc2.8xlarge memiliki 16 irisan. Untuk informasi selengkapnya tentang jumlah irisan yang dimiliki setiap ukuran node, lihat [Tentang cluster dan node di Panduan](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html#rs-about-clusters-and-nodes) Manajemen *Pergeseran Merah Amazon*.
Semua node berpartisipasi dalam menjalankan query paralel, bekerja pada data yang didistribusikan secara merata di seluruh irisan. Jika Anda memiliki cluster dengan dua node dc2.large, Anda dapat membagi data Anda menjadi empat file atau beberapa kelipatan dari empat. Amazon Redshift tidak memperhitungkan ukuran file saat membagi beban kerja. Dengan demikian, Anda perlu memastikan bahwa file berukuran kira-kira sama, dari 1 MB hingga 1 GB setelah kompresi.
Untuk menggunakan awalan objek untuk mengidentifikasi file beban, beri nama setiap file dengan awalan umum. Misalnya, Anda mungkin membagi `venue.txt` file mungkin dibagi menjadi empat file, sebagai berikut.
```
venue.txt.1
venue.txt.2
venue.txt.3
venue.txt.4
```
Jika Anda meletakkan beberapa file dalam folder di bucket Anda dan menentukan nama folder sebagai awalan, COPY memuat semua file dalam folder. Jika Anda secara eksplisit mencantumkan file yang akan dimuat menggunakan file manifes, file dapat berada di bucket atau folder yang berbeda.
Untuk informasi selengkapnya tentang file manifes, lihat[Menggunakan manifes untuk menentukan file data](r_COPY_command_examples.md#copy-command-examples-manifest).
## Memuat data dari file yang tidak terkompresi dan dibatasi
Saat Anda memuat data yang tidak terkompresi dan dibatasi, perintah COPY menggunakan arsitektur massively parallel processing (MPP) di Amazon Redshift. Amazon Redshift secara otomatis menggunakan irisan yang bekerja secara paralel untuk memuat rentang data dari file besar di bucket Amazon S3. File harus dibatasi agar pemuatan paralel terjadi. Misalnya, pipa dibatasi. Pemuatan data paralel otomatis dengan perintah COPY juga tersedia untuk file CSV. Anda juga dapat memanfaatkan pemrosesan paralel dengan mengatur kunci distribusi pada tabel Anda. Untuk informasi selengkapnya tentang kunci distribusi, lihat[Distribusi data untuk optimasi kueri](t_Distributing_data.md).
Pemuatan data paralel otomatis tidak didukung ketika kueri COPY menyertakan salah satu kata kunci berikut: ESCAPE, REMOVEQUOTES, dan FIXEDWIDTH.
Data dari file atau file dimuat ke dalam tabel target, satu baris per baris. Bidang dalam file data dicocokkan dengan kolom tabel secara berurutan, kiri ke kanan. Bidang dalam file data dapat dengan lebar tetap atau dibatasi karakter; pembatas default adalah pipa (\$1). Secara default, semua kolom tabel dimuat, tetapi Anda dapat secara opsional menentukan daftar kolom yang dipisahkan koma. Jika kolom tabel tidak disertakan dalam daftar kolom yang ditentukan dalam perintah COPY, kolom tersebut dimuat dengan nilai default. Untuk informasi selengkapnya, lihat [Memuat nilai kolom default](c_loading_default_values.md).
Ikuti proses umum ini untuk memuat data dari Amazon S3, saat data Anda tidak dikompresi dan dibatasi:
1. Unggah file Anda ke Amazon S3.
1. Jalankan perintah COPY untuk memuat tabel.
1. Verifikasi bahwa data dimuat dengan benar.
Untuk contoh perintah COPY, lihat[Contoh COPY](r_COPY_command_examples.md). Untuk informasi tentang data yang dimuat ke Amazon Redshift, periksa tabel [STL\$1LOAD\$1COMMIT](r_STL_LOAD_COMMITS.md) dan [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md) sistem.
Untuk informasi selengkapnya tentang node dan irisan yang terdapat di masing-masing node, lihat [Tentang cluster dan node](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html#rs-about-clusters-and-nodes) di Panduan Manajemen *Pergeseran Merah Amazon*.
# Mengunggah file ke Amazon S3 untuk digunakan dengan COPY
Ada beberapa pendekatan yang harus diambil saat mengunggah file teks ke Amazon S3:
+ Jika Anda memiliki file terkompresi, kami sarankan Anda membagi file besar untuk memanfaatkan pemrosesan paralel di Amazon Redshift.
+ Di sisi lain, COPY secara otomatis membagi data file besar, tidak terkompresi, dibatasi teks untuk memfasilitasi paralelisme dan secara efektif mendistribusikan data dari file besar.
Buat bucket Amazon S3 untuk menyimpan file data Anda, lalu unggah file data ke bucket. Untuk informasi tentang membuat bucket dan mengunggah file, lihat [Bekerja dengan Bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html) di Panduan Pengguna Layanan Penyimpanan *Sederhana Amazon*.
**penting**
Bucket Amazon S3 yang menyimpan file data harus dibuat di AWS Wilayah yang sama dengan cluster Anda kecuali Anda menggunakan [REGION](copy-parameters-data-source-s3.md#copy-region) opsi untuk menentukan Wilayah tempat bucket Amazon S3 berada.
Pastikan rentang IP S3 ditambahkan ke daftar yang diizinkan Anda. Untuk mempelajari lebih lanjut tentang rentang IP S3 yang diperlukan, lihat [Isolasi jaringan](https://docs.aws.amazon.com//redshift/latest/mgmt/security-network-isolation.html#network-isolation).
Anda dapat membuat bucket Amazon S3 di Wilayah tertentu baik dengan memilih Wilayah saat membuat bucket menggunakan konsol Amazon S3, atau dengan menentukan titik akhir saat membuat bucket menggunakan Amazon S3 API atau CLI.
Setelah pemuatan data, verifikasi bahwa file yang benar ada di Amazon S3.
**Topics**
+ [Mengelola konsistensi data](managing-data-consistency.md)
+ [Mengunggah data terenkripsi ke Amazon S3](t_uploading-encrypted-data.md)
+ [Memverifikasi bahwa file yang benar ada di bucket Anda](verifying-that-correct-files-are-present.md)
# Mengelola konsistensi data
Amazon S3 memberikan read-after-write konsistensi yang kuat untuk operasi COPY, UNLOAD, INSERT (tabel eksternal), CREATE EXTERNAL TABLE AS, dan Amazon Redshift Spectrum pada bucket Amazon S3 di semua Wilayah. AWS Selain itu, operasi baca di Amazon S3 Select, Daftar Kontrol Akses Amazon S3, Tag Objek Amazon S3, dan metadata objek (misalnya, objek HEAD) sangat konsisten. Untuk informasi selengkapnya tentang konsistensi data, lihat [Model Konsistensi Data Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Introduction.html#ConsistencyModel) di *Panduan Pengguna Layanan Penyimpanan Sederhana Amazon*.
# Mengunggah data terenkripsi ke Amazon S3
Amazon S3 mendukung enkripsi sisi server dan enkripsi sisi klien. Topik ini membahas perbedaan antara enkripsi sisi server dan sisi klien dan menjelaskan langkah-langkah untuk menggunakan enkripsi sisi klien dengan Amazon Redshift. Enkripsi sisi server transparan untuk Amazon Redshift.
## enkripsi di sisi server
Enkripsi sisi server adalah enkripsi data saat istirahat—yaitu, Amazon S3 mengenkripsi data Anda saat mengunggahnya dan mendekripsi untuk Anda saat Anda mengaksesnya. Saat Anda memuat tabel menggunakan perintah COPY, tidak ada perbedaan dalam cara Anda memuat dari objek terenkripsi atau tidak terenkripsi sisi server di Amazon S3. Untuk informasi selengkapnya tentang enkripsi sisi server, lihat [Menggunakan Enkripsi Sisi Server di Panduan Pengguna](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html) Layanan Penyimpanan *Sederhana Amazon*.
## Enkripsi di sisi klien
Dalam enkripsi sisi klien, aplikasi klien Anda mengelola enkripsi data Anda, kunci enkripsi, dan alat terkait. Anda dapat mengunggah data ke bucket Amazon S3 menggunakan enkripsi sisi klien, lalu memuat data menggunakan perintah COPY dengan opsi ENCRYPTED dan kunci enkripsi pribadi untuk memberikan keamanan yang lebih besar.
Anda mengenkripsi data Anda menggunakan enkripsi amplop. Dengan *enkripsi amplop,* aplikasi Anda menangani semua enkripsi secara eksklusif. Kunci enkripsi pribadi Anda dan data tidak terenkripsi Anda tidak pernah dikirim ke AWS, jadi sangat penting bagi Anda untuk mengelola kunci enkripsi dengan aman. Jika Anda kehilangan kunci enkripsi, Anda tidak akan dapat membatalkan enkripsi data Anda, dan Anda tidak dapat memulihkan kunci enkripsi Anda. AWS Enkripsi amplop menggabungkan kinerja enkripsi simetris cepat sambil mempertahankan keamanan yang lebih besar yang disediakan oleh manajemen kunci dengan kunci asimetris. Kunci one-time-use simetris (kunci simetris amplop) dihasilkan oleh klien enkripsi Amazon S3 Anda untuk mengenkripsi data Anda, kemudian kunci itu dienkripsi oleh kunci root Anda dan disimpan bersama data Anda di Amazon S3. Saat Amazon Redshift mengakses data Anda selama pemuatan, kunci simetris terenkripsi diambil dan didekripsi dengan kunci asli Anda, lalu data didekripsi.
Untuk bekerja dengan data terenkripsi sisi klien Amazon S3 di Amazon Redshift, ikuti langkah-langkah yang diuraikan dalam [Melindungi Data Menggunakan Enkripsi Sisi Klien](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingClientSideEncryption.html) di Panduan Pengguna *Layanan Penyimpanan Sederhana Amazon*, dengan persyaratan tambahan yang Anda gunakan:
+ **Enkripsi simetris —** AWS SDK for `AmazonS3EncryptionClient` Java class menggunakan enkripsi amplop, dijelaskan sebelumnya, yang didasarkan pada enkripsi kunci simetris. Gunakan kelas ini untuk membuat klien Amazon S3 untuk mengunggah data terenkripsi sisi klien.
+ Kunci **simetris root AES 256-bit — Kunci** root mengenkripsi kunci amplop. Anda meneruskan kunci root ke instance `AmazonS3EncryptionClient` kelas Anda. Simpan kunci ini, karena Anda akan membutuhkannya untuk menyalin data ke Amazon Redshift.
+ **Metadata objek untuk menyimpan kunci amplop terenkripsi — Secara default, Amazon S3 menyimpan kunci** amplop sebagai metadata objek untuk kelas. `AmazonS3EncryptionClient` Kunci amplop terenkripsi yang disimpan sebagai metadata objek digunakan selama proses dekripsi.
**catatan**
Jika Anda mendapatkan pesan kesalahan enkripsi sandi saat Anda menggunakan API enkripsi untuk pertama kalinya, versi JDK Anda mungkin memiliki file kebijakan yurisdiksi Java Cryptography Extension (JCE) yang membatasi panjang kunci maksimum untuk enkripsi dan transformasi dekripsi menjadi 128 bit. Untuk informasi tentang mengatasi masalah ini, buka [Menentukan Enkripsi Sisi Klien Menggunakan SDK for AWS Java](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingClientSideEncryptionUpload.html) di Panduan Pengguna Layanan Penyimpanan Sederhana *Amazon*.
Untuk informasi tentang memuat file terenkripsi sisi klien ke dalam tabel Amazon Redshift menggunakan perintah COPY, lihat. [Memuat file data terenkripsi dari Amazon S3](c_loading-encrypted-files.md)
## Contoh: Mengunggah data terenkripsi sisi klien
*Untuk contoh cara menggunakan AWS SDK for Java untuk mengunggah data terenkripsi sisi klien, buka [Melindungi data menggunakan enkripsi sisi klien](https://docs.aws.amazon.com/AmazonS3/latest/userguide/encrypt-client-side-symmetric-master-key.html) di Panduan Pengguna Layanan Penyimpanan Sederhana Amazon.*
Opsi kedua menunjukkan pilihan yang harus Anda buat selama enkripsi sisi klien sehingga data dapat dimuat di Amazon Redshift. Secara khusus, contoh menunjukkan penggunaan metadata objek untuk menyimpan kunci amplop terenkripsi dan penggunaan kunci simetris akar AES 256-bit.
Contoh ini memberikan contoh kode menggunakan AWS SDK for Java untuk membuat kunci root simetris AES 256-bit dan menyimpannya ke file. Kemudian contoh mengunggah objek ke Amazon S3 menggunakan klien enkripsi S3 yang pertama mengenkripsi data sampel di sisi klien. Contoh ini juga mengunduh objek dan memverifikasi bahwa datanya sama.
# Memverifikasi bahwa file yang benar ada di bucket Anda
Setelah Anda mengunggah file ke bucket Amazon S3, sebaiknya cantumkan konten bucket untuk memverifikasi bahwa semua file yang benar ada dan tidak ada file yang tidak diinginkan. Misalnya, jika bucket `amzn-s3-demo-bucket` menyimpan file bernama`venue.txt.back`, file itu akan dimuat, mungkin secara tidak sengaja, dengan perintah berikut:
```
COPY venue FROM 's3://amzn-s3-demo-bucket/venue' … ;
```
Jika Anda ingin mengontrol secara spesifik file mana yang dimuat, Anda dapat menggunakan file manifes untuk secara eksplisit mencantumkan file data. Untuk informasi selengkapnya tentang menggunakan file manifes, lihat [copy_from_s3_manifest_file](copy-parameters-data-source-s3.md#copy-manifest-file) opsi untuk perintah COPY dan [Menggunakan manifes untuk menentukan file data](r_COPY_command_examples.md#copy-command-examples-manifest) dalam contoh COPY.
Untuk informasi selengkapnya tentang mencantumkan konten bucket, lihat [Daftar Kunci Objek](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ListingKeysUsingAPIs.html) di Panduan *Pengembang Amazon S3*.
# Menggunakan perintah COPY untuk memuat dari Amazon S3
Gunakan [MENYONTEK](r_COPY.md) perintah untuk memuat tabel secara paralel dari file data di Amazon S3. Anda dapat menentukan file yang akan dimuat menggunakan awalan objek Amazon S3 atau dengan menggunakan file manifes.
Sintaks untuk menentukan file yang akan dimuat dengan menggunakan awalan adalah sebagai berikut:
```
COPY FROM 's3:///'
authorization;
```
File manifes adalah file berformat JSON yang mencantumkan file data yang akan dimuat. Sintaks untuk menentukan file yang akan dimuat dengan menggunakan file manifes adalah sebagai berikut:
```
COPY FROM 's3:///'
authorization
MANIFEST;
```
Tabel yang akan dimuat harus sudah ada dalam database. Untuk informasi tentang membuat tabel, lihat [CREATE TABLE](r_CREATE_TABLE_NEW.md) di Referensi SQL.
Nilai untuk *otorisasi memberikan otorisasi* yang AWS dibutuhkan Amazon Redshift untuk mengakses objek Amazon S3. Untuk informasi tentang izin yang diperlukan, lihat[Izin IAM untuk COPY, UNLOAD, dan CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions). Metode yang lebih disukai untuk otentikasi adalah menentukan parameter IAM\$1ROLE dan memberikan Amazon Resource Name (ARN) untuk peran IAM dengan izin yang diperlukan. Untuk informasi selengkapnya, lihat [Kontrol akses berbasis peran](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
Untuk mengautentikasi menggunakan parameter IAM\$1ROLE, ganti ** dan ** seperti yang ditunjukkan dalam sintaks berikut.
```
IAM_ROLE 'arn:aws:iam:::role/'
```
Contoh berikut menunjukkan otentikasi menggunakan peran IAM.
```
COPY customer
FROM 's3://amzn-s3-demo-bucket/mydata'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Untuk informasi selengkapnya tentang opsi otorisasi lainnya, lihat [Parameter otorisasi](copy-parameters-authorization.md)
Jika Anda ingin memvalidasi data Anda tanpa benar-benar memuat tabel, gunakan opsi NOLOAD dengan perintah. [MENYONTEK](r_COPY.md)
Contoh berikut menunjukkan beberapa baris pertama dari data yang dibatasi pipa dalam file bernama. `venue.txt`
```
1|Toyota Park|Bridgeview|IL|0
2|Columbus Crew Stadium|Columbus|OH|0
3|RFK Stadium|Washington|DC|0
```
Sebelum mengunggah file ke Amazon S3, pisahkan file menjadi beberapa file sehingga perintah COPY dapat memuatnya menggunakan pemrosesan paralel. Jumlah file harus kelipatan dari jumlah irisan di cluster Anda. Pisahkan file data beban Anda sehingga file berukuran hampir sama, antara 1 MB dan 1 GB setelah kompresi. Untuk informasi selengkapnya, lihat [Memuat data dari file terkompresi dan tidak terkompresi](t_splitting-data-files.md).
Misalnya, `venue.txt` file tersebut dapat dibagi menjadi empat file, sebagai berikut:
```
venue.txt.1
venue.txt.2
venue.txt.3
venue.txt.4
```
Perintah COPY berikut memuat tabel VENUE menggunakan data yang dibatasi pipa dalam file data dengan awalan 'venue' di bucket Amazon S3. `amzn-s3-demo-bucket`
**catatan**
Bucket Amazon S3 `amzn-s3-demo-bucket` dalam contoh berikut tidak ada. Untuk contoh perintah COPY yang menggunakan data nyata di bucket Amazon S3 yang ada, lihat [Memuat data sampel](https://docs.aws.amazon.com/redshift/latest/gsg/cm-dev-t-load-sample-data.html).
```
COPY venue FROM 's3://amzn-s3-demo-bucket/venue'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
DELIMITER '|';
```
Jika tidak ada objek Amazon S3 dengan awalan kunci 'venue' yang ada, pemuatan gagal.
**Topics**
+ [Menggunakan manifes untuk menentukan file data](loading-data-files-using-manifest.md)
+ [Memuat file data terkompresi dari Amazon S3](t_loading-gzip-compressed-data-files-from-S3.md)
+ [Memuat data dengan lebar tetap dari Amazon S3](t_loading_fixed_width_data.md)
+ [Memuat data multibyte dari Amazon S3](t_loading_unicode_data.md)
+ [Memuat file data terenkripsi dari Amazon S3](c_loading-encrypted-files.md)
# Menggunakan manifes untuk menentukan file data
Anda dapat menggunakan manifes untuk memastikan bahwa perintah COPY memuat semua file yang diperlukan, dan hanya file yang diperlukan, untuk memuat data. Anda dapat menggunakan manifes untuk memuat file dari berbagai bucket atau file yang tidak memiliki awalan yang sama. Alih-alih menyediakan jalur objek untuk perintah COPY, Anda memberikan nama file teks berformat JSON yang secara eksplisit mencantumkan file yang akan dimuat. URL dalam manifes harus menentukan nama bucket dan path objek lengkap untuk file, bukan hanya awalan.
Untuk informasi selengkapnya tentang file manifes, lihat contoh COPY [Menggunakan manifes untuk menentukan file data](r_COPY_command_examples.md#copy-command-examples-manifest).
Contoh berikut menunjukkan JSON untuk memuat file dari bucket yang berbeda dan dengan nama file yang dimulai dengan stempel tanggal.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/2013-10-04-custdata", "mandatory":true},
{"url":"s3://amzn-s3-demo-bucket1/2013-10-05-custdata", "mandatory":true},
{"url":"s3://amzn-s3-demo-bucket2/2013-10-04-custdata", "mandatory":true},
{"url":"s3://amzn-s3-demo-bucket2/2013-10-05-custdata", "mandatory":true}
]
}
```
`mandatory`Bendera opsional menentukan apakah COPY harus mengembalikan kesalahan jika file tidak ditemukan. `mandatory`Defaultnya adalah`false`. Terlepas dari pengaturan wajib apa pun, COPY akan berakhir jika tidak ada file yang ditemukan.
Contoh berikut menjalankan perintah COPY dengan manifes dalam contoh sebelumnya, yang diberi nama`cust.manifest`.
```
COPY customer
FROM 's3://amzn-s3-demo-bucket/cust.manifest'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
MANIFEST;
```
## Menggunakan manifes yang dibuat oleh UNLOAD
Manifes yang dibuat oleh [MEMBONGKAR](r_UNLOAD.md) operasi menggunakan parameter MANIFEST mungkin memiliki kunci yang tidak diperlukan untuk operasi COPY. Misalnya, `UNLOAD` manifes berikut menyertakan `meta` kunci yang diperlukan untuk tabel eksternal Amazon Redshift Spectrum dan untuk memuat file data dalam format `ORC` file `Parquet` atau. `meta`Kunci berisi `content_length` kunci dengan nilai yang merupakan ukuran sebenarnya dari file dalam byte. Operasi COPY hanya membutuhkan `url` kunci dan `mandatory` kunci opsional.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket/unload/manifest_0000_part_00", "meta": { "content_length": 5956875 }},
{"url":"s3://amzn-s3-demo-bucket/unload/unload/manifest_0001_part_00", "meta": { "content_length": 5997091 }}
]
}
```
Untuk informasi selengkapnya tentang file manifes, lihat[Menggunakan manifes untuk menentukan file data](r_COPY_command_examples.md#copy-command-examples-manifest).
# Memuat file data terkompresi dari Amazon S3
Untuk memuat file data yang dikompresi menggunakan gzip, lzop, atau bzip2, sertakan opsi yang sesuai: GZIP, LZOP, atau. BZIP2
Misalnya, perintah berikut dimuat dari file yang dikompresi menggunakan lzop.
```
COPY customer FROM 's3://amzn-s3-demo-bucket/customer.lzo'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
DELIMITER '|' LZOP;
```
**catatan**
Jika Anda mengompres file data dengan kompresi lzop dan menggunakan opsi *--filter*, perintah COPY tidak mendukungnya.
# Memuat data dengan lebar tetap dari Amazon S3
File data dengan lebar tetap memiliki panjang yang seragam untuk setiap kolom data. Setiap bidang dalam file data dengan lebar tetap memiliki panjang dan posisi yang persis sama. Untuk data karakter (CHAR dan VARCHAR) dalam file data dengan lebar tetap, Anda harus menyertakan spasi depan atau belakang sebagai placeholder agar lebarnya tetap seragam. Untuk bilangan bulat, Anda harus menggunakan angka nol di depan sebagai placeholder. File data dengan lebar tetap tidak memiliki pembatas untuk memisahkan kolom.
Untuk memuat file data dengan lebar tetap ke dalam tabel yang ada, GUNAKAN parameter FIXEDWIDTH dalam perintah COPY. Spesifikasi tabel Anda harus sesuai dengan nilai fixedwidth\$1spec agar data dapat dimuat dengan benar.
Untuk memuat data dengan lebar tetap dari file ke tabel, keluarkan perintah berikut:
```
COPY table_name FROM 's3://amzn-s3-demo-bucket/prefix'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
FIXEDWIDTH 'fixedwidth_spec';
```
Parameter *fixedwidth\$1spec* adalah string yang berisi pengidentifikasi untuk setiap kolom dan lebar setiap kolom, dipisahkan oleh titik dua. **column:width**Pasangan dibatasi oleh koma. Pengenal dapat berupa apa saja yang Anda pilih: angka, huruf, atau kombinasi keduanya. Pengidentifikasi tidak memiliki hubungan dengan tabel itu sendiri, sehingga spesifikasi harus berisi kolom dalam urutan yang sama dengan tabel.
Dua contoh berikut menunjukkan spesifikasi yang sama, dengan yang pertama menggunakan pengidentifikasi numerik dan yang kedua menggunakan pengidentifikasi string:
```
'0:3,1:25,2:12,3:2,4:6'
```
```
'venueid:3,venuename:25,venuecity:12,venuestate:2,venueseats:6'
```
Contoh berikut menunjukkan data sampel lebar tetap yang dapat dimuat ke dalam tabel VENUE menggunakan spesifikasi sebelumnya:
```
1 Toyota Park Bridgeview IL0
2 Columbus Crew Stadium Columbus OH0
3 RFK Stadium Washington DC0
4 CommunityAmerica Ballpark Kansas City KS0
5 Gillette Stadium Foxborough MA68756
```
Perintah COPY berikut memuat kumpulan data ini ke dalam tabel VENUE:
```
COPY venue
FROM 's3://amzn-s3-demo-bucket/data/venue_fw.txt'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
FIXEDWIDTH 'venueid:3,venuename:25,venuecity:12,venuestate:2,venueseats:6';
```
# Memuat data multibyte dari Amazon S3
Jika data Anda menyertakan karakter multibyte non-ASCII (seperti karakter Mandarin atau Sirilik), Anda harus memuat data ke kolom VARCHAR. Tipe data VARCHAR mendukung karakter UTF-8 empat byte, tetapi tipe data CHAR hanya menerima karakter ASCII single-byte. Anda tidak dapat memuat karakter lima byte atau lebih panjang ke dalam tabel Amazon Redshift. Untuk informasi lebih lanjut tentang CHAR dan VARCHAR, lihat. [Jenis Data](c_Supported_data_types.md)
Untuk memeriksa pengkodean mana yang digunakan file input, gunakan *`file`*perintah Linux:
```
$ file ordersdata.txt
ordersdata.txt: ASCII English text
$ file uni_ordersdata.dat
uni_ordersdata.dat: UTF-8 Unicode text
```
# Memuat file data terenkripsi dari Amazon S3
Anda dapat menggunakan perintah COPY untuk memuat file data yang diunggah ke Amazon S3 menggunakan enkripsi sisi server, enkripsi sisi klien, atau keduanya.
Perintah COPY mendukung jenis enkripsi Amazon S3 berikut:
+ Enkripsi sisi server dengan kunci yang dikelola Amazon S3 (SSE-S3)
+ Enkripsi sisi server dengan AWS KMS keys (SSE-KMS)
+ Enkripsi sisi klien menggunakan kunci root simetris sisi klien
Perintah COPY tidak mendukung jenis enkripsi Amazon S3 berikut:
+ Enkripsi di sisi server dengan kunci yang disediakan pelanggan (SSE-C)
+ Enkripsi sisi klien menggunakan AWS KMS key
+ Enkripsi sisi klien menggunakan kunci root asimetris yang disediakan pelanggan
Untuk informasi selengkapnya tentang enkripsi Amazon S3, lihat [Melindungi Data Menggunakan Enkripsi Sisi Server dan Melindungi Data Menggunakan Enkripsi Sisi](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) [Klien di Panduan Pengguna Layanan](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingClientSideEncryption.html) Penyimpanan Sederhana Amazon.
[MEMBONGKAR](r_UNLOAD.md)Perintah secara otomatis mengenkripsi file menggunakan SSE-S3. Anda juga dapat membongkar menggunakan SSE-KMS atau enkripsi sisi klien dengan kunci simetris yang dikelola pelanggan. Untuk informasi selengkapnya, lihat [Membongkar file data terenkripsi](t_unloading_encrypted_files.md)
Perintah COPY secara otomatis mengenali dan memuat file yang dienkripsi menggunakan SSE-S3 dan SSE-KMS. Anda dapat memuat file yang dienkripsi menggunakan kunci root simetris sisi klien dengan menentukan opsi ENCRYPTED dan memberikan nilai kunci. Untuk informasi selengkapnya, lihat [Mengunggah data terenkripsi ke Amazon S3](t_uploading-encrypted-data.md).
Untuk memuat file data terenkripsi sisi klien, berikan nilai kunci root menggunakan parameter MASTER\$1SYMMETRIC\$1KEY dan sertakan opsi ENCRYPTED.
```
COPY customer FROM 's3://amzn-s3-demo-bucket/encrypted/customer'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
MASTER_SYMMETRIC_KEY ''
ENCRYPTED
DELIMITER '|';
```
Untuk memuat file data terenkripsi yang gzip, lzop, atau bzip2 dikompresi, sertakan GZIP, LZOP, atau BZIP2 opsi bersama dengan nilai kunci root dan opsi ENCRYPTED.
```
COPY customer FROM 's3://amzn-s3-demo-bucket/encrypted/customer'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
MASTER_SYMMETRIC_KEY ''
ENCRYPTED
DELIMITER '|'
GZIP;
```
# Memuat data dari Amazon EMR
Anda dapat menggunakan perintah COPY untuk memuat data secara paralel dari kluster EMR Amazon yang dikonfigurasi untuk menulis file teks ke Hadoop Distributed File System (HDFS) cluster sebagai file dengan lebar tetap, file yang dibatasi karakter, file CSV, atau file berformat JSON.
## Proses untuk memuat data dari Amazon EMR
Bagian ini memandu Anda melalui proses memuat data dari cluster EMR Amazon. Bagian berikut memberikan rincian yang harus Anda capai setiap langkah.
+ **[Langkah 1: Konfigurasikan izin IAM](#load-from-emr-steps-configure-iam)**
Pengguna yang membuat cluster EMR Amazon dan menjalankan perintah Amazon Redshift COPY harus memiliki izin yang diperlukan.
+ **[Langkah 2: Buat cluster EMR Amazon](#load-from-emr-steps-create-cluster)**
Konfigurasikan cluster untuk mengeluarkan file teks ke Hadoop Distributed File System (HDFS). Anda akan memerlukan ID klaster EMR Amazon dan DNS publik utama klaster (titik akhir untuk instans Amazon EC2 yang menghosting cluster).
+ **[Langkah 3: Ambil kunci publik klaster Amazon Redshift dan alamat IP node cluster](#load-from-emr-steps-retrieve-key-and-ips)**
Kunci publik memungkinkan node cluster Amazon Redshift untuk membuat koneksi SSH ke host. Anda akan menggunakan alamat IP untuk setiap node cluster untuk mengonfigurasi grup keamanan host untuk mengizinkan akses dari cluster Amazon Redshift Anda menggunakan alamat IP ini.
+ **[Langkah 4: Tambahkan kunci publik klaster Amazon Redshift ke setiap file kunci resmi host Amazon EC2](#load-from-emr-steps-add-key-to-host)**
Anda menambahkan kunci publik klaster Amazon Redshift ke file kunci resmi host sehingga host akan mengenali klaster Amazon Redshift dan menerima koneksi SSH.
+ **[Langkah 5: Konfigurasikan host untuk menerima semua alamat IP cluster Amazon Redshift](#load-from-emr-steps-configure-security-groups)**
Ubah grup keamanan instans EMR Amazon untuk menambahkan aturan input guna menerima alamat IP Amazon Redshift.
+ **[Langkah 6: Jalankan perintah COPY untuk memuat data](#load-from-emr-steps-run-copy)**
Dari database Amazon Redshift, jalankan perintah COPY untuk memuat data ke dalam tabel Amazon Redshift.
## Langkah 1: Konfigurasikan izin IAM
Pengguna yang membuat cluster EMR Amazon dan menjalankan perintah Amazon Redshift COPY harus memiliki izin yang diperlukan.
**Untuk mengonfigurasi izin IAM**
1. Tambahkan izin berikut untuk pengguna yang akan membuat cluster EMR Amazon.
```
ec2:DescribeSecurityGroups
ec2:RevokeSecurityGroupIngress
ec2:AuthorizeSecurityGroupIngress
redshift:DescribeClusters
```
1. Tambahkan izin berikut untuk peran IAM atau pengguna yang akan menjalankan perintah COPY.
```
elasticmapreduce:ListInstances
```
1. Tambahkan izin berikut ke peran IAM klaster EMR Amazon.
```
redshift:DescribeClusters
```
## Langkah 2: Buat cluster EMR Amazon
Perintah COPY memuat data dari file di Amazon EMR Hadoop Distributed File System (HDFS). Saat Anda membuat kluster EMR Amazon, konfigurasikan cluster untuk mengeluarkan file data ke HDFS cluster.
**Untuk membuat cluster EMR Amazon**
1. Buat klaster EMR Amazon di AWS Wilayah yang sama dengan cluster Amazon Redshift.
Jika cluster Amazon Redshift berada dalam VPC, cluster EMR Amazon harus berada dalam grup VPC yang sama. Jika cluster Amazon Redshift menggunakan mode EC2-Classic (yaitu, tidak dalam VPC), cluster EMR Amazon juga harus menggunakan mode EC2-Classic. *Untuk informasi selengkapnya, lihat [Mengelola Cluster di Virtual Private Cloud (VPC) di](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-clusters-vpc.html) Panduan Manajemen Amazon Redshift.*
1. Konfigurasikan cluster untuk mengeluarkan file data ke HDFS cluster. Nama file HDFS tidak boleh menyertakan tanda bintang (\$1) atau tanda tanya (?).
**penting**
Nama file tidak boleh menyertakan tanda bintang (\$1) atau tanda tanya (? ).
1. Tentukan **Tidak** untuk opsi **Auto-terminate** dalam konfigurasi klaster EMR Amazon sehingga cluster tetap tersedia saat perintah COPY berjalan.
**penting**
Jika salah satu file data diubah atau dihapus sebelum COPY selesai, Anda mungkin memiliki hasil yang tidak terduga, atau operasi COPY mungkin gagal.
1. Perhatikan ID cluster dan DNS publik utama (titik akhir untuk instans Amazon EC2 yang menghosting cluster). Anda akan menggunakan informasi itu di langkah selanjutnya.
## Langkah 3: Ambil kunci publik klaster Amazon Redshift dan alamat IP node cluster
Anda akan menggunakan alamat IP untuk setiap node cluster untuk mengonfigurasi grup keamanan host untuk mengizinkan akses dari cluster Amazon Redshift Anda menggunakan alamat IP ini.
**Untuk mengambil kunci publik klaster Amazon Redshift dan alamat IP node cluster untuk klaster Anda menggunakan konsol**
1. Akses Konsol Manajemen Amazon Redshift.
1. Pilih tautan **Clusters** di panel navigasi.
1. Pilih klaster Anda dari daftar.
1. Temukan grup Pengaturan **Penyerapan SSH**.
Perhatikan **alamat IP **Cluster Public Key** dan Node**. Anda akan menggunakannya di langkah selanjutnya.
![\[Screenshot dari grup SSH Ingestion Settings yang menunjukkan alamat IP Cluster Public Key dan Node.\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/images/copy-from-ssh-console-2.png)
Anda akan menggunakan alamat IP pribadi di Langkah 3 untuk mengonfigurasi host Amazon EC2 untuk menerima koneksi dari Amazon Redshift.
Untuk mengambil kunci publik klaster dan alamat IP node cluster untuk klaster Anda menggunakan Amazon Redshift CLI, jalankan perintah describe-clusters. Contoh:
```
aws redshift describe-clusters --cluster-identifier
```
Respons akan mencakup ClusterPublicKey nilai dan daftar alamat IP pribadi dan publik, mirip dengan yang berikut ini:
```
{
"Clusters": [
{
"VpcSecurityGroups": [],
"ClusterStatus": "available",
"ClusterNodes": [
{
"PrivateIPAddress": "10.nnn.nnn.nnn",
"NodeRole": "LEADER",
"PublicIPAddress": "10.nnn.nnn.nnn"
},
{
"PrivateIPAddress": "10.nnn.nnn.nnn",
"NodeRole": "COMPUTE-0",
"PublicIPAddress": "10.nnn.nnn.nnn"
},
{
"PrivateIPAddress": "10.nnn.nnn.nnn",
"NodeRole": "COMPUTE-1",
"PublicIPAddress": "10.nnn.nnn.nnn"
}
],
"AutomatedSnapshotRetentionPeriod": 1,
"PreferredMaintenanceWindow": "wed:05:30-wed:06:00",
"AvailabilityZone": "us-east-1a",
"NodeType": "dc2.large",
"ClusterPublicKey": "ssh-rsa AAAABexamplepublickey...Y3TAl Amazon-Redshift",
...
...
}
```
Untuk mengambil kunci publik klaster dan alamat IP node cluster untuk klaster Anda menggunakan Amazon Redshift API, gunakan `DescribeClusters` tindakan tersebut. Untuk informasi [selengkapnya, lihat deskripsikan klaster](https://docs.aws.amazon.com/cli/latest/reference/redshift/describe-clusters.html) di Panduan *CLI Amazon Redshift atau [DescribeClusters](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html)di Panduan* Amazon Redshift API.
## Langkah 4: Tambahkan kunci publik klaster Amazon Redshift ke setiap file kunci resmi host Amazon EC2
Anda menambahkan kunci publik klaster ke file kunci resmi masing-masing host untuk semua node cluster EMR Amazon sehingga host akan mengenali Amazon Redshift dan menerima koneksi SSH.
**Untuk menambahkan kunci publik klaster Amazon Redshift ke file kunci resmi host**
1. Akses host menggunakan koneksi SSH.
Untuk informasi tentang menghubungkan ke instans menggunakan SSH, lihat [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-connect-to-instance-linux.html) di Panduan *Pengguna Amazon EC2*.
1. Salin kunci publik Amazon Redshift dari konsol atau dari teks respons CLI.
1. Salin dan tempel isi kunci publik ke dalam `/home//.ssh/authorized_keys` file di host. Sertakan string lengkap, termasuk awalan "`ssh-rsa`" dan akhiran "”`Amazon-Redshift`. Contoh:
```
ssh-rsa AAAACTP3isxgGzVWoIWpbVvRCOzYdVifMrh… uA70BnMHCaMiRdmvsDOedZDOedZ Amazon-Redshift
```
## Langkah 5: Konfigurasikan host untuk menerima semua alamat IP cluster Amazon Redshift
Untuk mengizinkan lalu lintas masuk ke instans host, edit grup keamanan dan tambahkan satu aturan Inbound untuk setiap node cluster Amazon Redshift. Untuk **Type**, pilih SSH dengan protokol TCP pada Port 22. Untuk **Sumber**, masukkan alamat IP pribadi node cluster Amazon Redshift yang Anda ambil. [Langkah 3: Ambil kunci publik klaster Amazon Redshift dan alamat IP node cluster](#load-from-emr-steps-retrieve-key-and-ips) *Untuk informasi tentang menambahkan aturan ke grup keamanan Amazon EC2, lihat [Mengotorisasi Lalu Lintas Masuk untuk Instans Anda di](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) Panduan Pengguna Amazon EC2.*
## Langkah 6: Jalankan perintah COPY untuk memuat data
Jalankan [MENYONTEK](r_COPY.md) perintah untuk menyambung ke kluster EMR Amazon dan memuat data ke dalam tabel Amazon Redshift. Cluster EMR Amazon harus terus berjalan hingga perintah COPY selesai. Misalnya, jangan mengkonfigurasi cluster untuk mengakhiri otomatis.
**penting**
Jika salah satu file data diubah atau dihapus sebelum COPY selesai, Anda mungkin memiliki hasil yang tidak terduga, atau operasi COPY mungkin gagal.
Dalam perintah COPY, tentukan ID cluster EMR Amazon dan jalur file HDFS dan nama file.
```
COPY sales
FROM 'emr://myemrclusterid/myoutput/part*' CREDENTIALS
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Anda dapat menggunakan karakter wildcard asterisk (`*`) dan tanda tanya (`?`) sebagai bagian dari argumen nama file. Misalnya, `part*` memuat file`part-0000`,`part-0001`, dan sebagainya. Jika Anda hanya menentukan nama folder, COPY mencoba memuat semua file di folder.
**penting**
Jika Anda menggunakan karakter wildcard atau hanya menggunakan nama folder, verifikasi bahwa tidak ada file yang tidak diinginkan yang akan dimuat atau perintah COPY akan gagal. Misalnya, beberapa proses mungkin menulis file log ke folder output.
# Memuat data dari host jarak jauh
Anda dapat menggunakan perintah COPY untuk memuat data secara paralel dari satu atau lebih host jarak jauh, seperti instans Amazon EC2 atau komputer lain. COPY terhubung ke host jarak jauh menggunakan SSH dan menjalankan perintah pada host jarak jauh untuk menghasilkan output teks.
Host jarak jauh dapat berupa instans Amazon EC2 Linux atau komputer Unix atau Linux lain yang dikonfigurasi untuk menerima koneksi SSH. Panduan ini mengasumsikan host jarak jauh Anda adalah instans Amazon EC2. Di mana prosedurnya berbeda untuk komputer lain, panduan akan menunjukkan perbedaannya.
Amazon Redshift dapat terhubung ke beberapa host, dan dapat membuka beberapa koneksi SSH ke setiap host. Amazon Redshifts mengirimkan perintah unik melalui setiap koneksi untuk menghasilkan output teks ke output standar host, yang kemudian dibaca Amazon Redshift seperti halnya file teks.
## Sebelum Anda mulai
Sebelum Anda mulai, Anda harus memiliki yang berikut:
+ Satu atau lebih mesin host, seperti instans Amazon EC2, yang dapat Anda sambungkan menggunakan SSH.
+ Sumber data pada host.
Anda akan memberikan perintah bahwa cluster Amazon Redshift akan berjalan pada host untuk menghasilkan output teks. Setelah cluster terhubung ke host, perintah COPY menjalankan perintah, membaca teks dari output standar host, dan memuat data secara paralel ke dalam tabel Amazon Redshift. Output teks harus dalam bentuk yang dapat dicerna oleh perintah COPY. Untuk informasi selengkapnya, lihat [Mempersiapkan data masukan Anda](t_preparing-input-data.md)
+ Akses ke host dari komputer Anda.
Untuk instans Amazon EC2, Anda akan menggunakan koneksi SSH untuk mengakses host. Anda harus mengakses host untuk menambahkan kunci publik klaster Amazon Redshift ke file kunci resmi host.
+ Cluster Amazon Redshift yang sedang berjalan.
Untuk informasi tentang cara meluncurkan klaster, lihat Panduan [Memulai Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/).
## Memuat proses data
Bagian ini memandu Anda melalui proses memuat data dari host jarak jauh. Bagian berikut memberikan rincian yang harus Anda capai di setiap langkah.
+ **[Langkah 1: Ambil kunci publik cluster dan alamat IP node cluster](#load-from-host-steps-retrieve-key-and-ips)**
Kunci publik memungkinkan node cluster Amazon Redshift untuk membuat koneksi SSH ke host jarak jauh. Anda akan menggunakan alamat IP untuk setiap node cluster untuk mengonfigurasi grup keamanan host atau firewall untuk mengizinkan akses dari cluster Amazon Redshift Anda menggunakan alamat IP ini.
+ **[Langkah 2: Tambahkan kunci publik klaster Amazon Redshift ke file kunci resmi host](#load-from-host-steps-add-key-to-host)**
Anda menambahkan kunci publik klaster Amazon Redshift ke file kunci resmi host sehingga host akan mengenali klaster Amazon Redshift dan menerima koneksi SSH.
+ **[Langkah 3: Konfigurasikan host untuk menerima semua alamat IP cluster Amazon Redshift](#load-from-host-steps-configure-security-groups)**
Untuk Amazon EC2, ubah grup keamanan instans untuk menambahkan aturan input guna menerima alamat IP Amazon Redshift. Untuk host lain, modifikasi firewall sehingga node Amazon Redshift Anda dapat membuat koneksi SSH ke host jarak jauh.
+ **[Langkah 4: Dapatkan kunci publik untuk tuan rumah](#load-from-host-steps-get-the-host-key)**
Anda dapat secara opsional menentukan bahwa Amazon Redshift harus menggunakan kunci publik untuk mengidentifikasi host. Anda harus menemukan kunci publik dan menyalin teks ke file manifes Anda.
+ **[Langkah 5: Buat file manifes](#load-from-host-steps-create-manifest)**
Manifes adalah file teks berformat JSON dengan detail yang dibutuhkan Amazon Redshift untuk terhubung ke host dan mengambil data.
+ **[Langkah 6: Unggah file manifes ke bucket Amazon S3](#load-from-host-steps-upload-manifest)**
Amazon Redshift membaca manifes dan menggunakan informasi tersebut untuk terhubung ke host jarak jauh. Jika bucket Amazon S3 tidak berada di Wilayah yang sama dengan cluster Amazon Redshift Anda, Anda harus menggunakan [REGION](copy-parameters-data-source-s3.md#copy-region) opsi untuk menentukan Wilayah tempat data berada.
+ **[Langkah 7: Jalankan perintah COPY untuk memuat data](#load-from-host-steps-run-copy)**
Dari database Amazon Redshift, jalankan perintah COPY untuk memuat data ke dalam tabel Amazon Redshift.
## Langkah 1: Ambil kunci publik cluster dan alamat IP node cluster
Anda akan menggunakan alamat IP untuk setiap node cluster untuk mengonfigurasi grup keamanan host untuk mengizinkan akses dari cluster Amazon Redshift Anda menggunakan alamat IP ini.
**Untuk mengambil kunci publik klaster dan alamat IP node cluster untuk cluster Anda menggunakan konsol**
1. Akses Konsol Manajemen Amazon Redshift.
1. Pilih tautan **Clusters** di panel navigasi.
1. Pilih klaster Anda dari daftar.
1. Temukan grup Pengaturan **Penyerapan SSH**.
Perhatikan **alamat IP **Cluster Public Key** dan Node**. Anda akan menggunakannya di langkah selanjutnya.
![\[Screenshot dari grup SSH Ingestion Settings yang menunjukkan alamat IP Cluster Public Key dan Node.\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/images/copy-from-ssh-console-2.png)
Anda akan menggunakan alamat IP di Langkah 3 untuk mengonfigurasi host untuk menerima koneksi dari Amazon Redshift. Tergantung pada jenis host yang Anda sambungkan dan apakah itu dalam VPC, Anda akan menggunakan alamat IP publik atau alamat IP pribadi.
Untuk mengambil kunci publik klaster dan alamat IP node cluster untuk klaster Anda menggunakan Amazon Redshift CLI, jalankan perintah describe-clusters.
Contoh:
```
aws redshift describe-clusters --cluster-identifier
```
Respons akan mencakup ClusterPublicKey dan daftar alamat IP pribadi dan publik, mirip dengan yang berikut ini:
```
{
"Clusters": [
{
"VpcSecurityGroups": [],
"ClusterStatus": "available",
"ClusterNodes": [
{
"PrivateIPAddress": "10.nnn.nnn.nnn",
"NodeRole": "LEADER",
"PublicIPAddress": "10.nnn.nnn.nnn"
},
{
"PrivateIPAddress": "10.nnn.nnn.nnn",
"NodeRole": "COMPUTE-0",
"PublicIPAddress": "10.nnn.nnn.nnn"
},
{
"PrivateIPAddress": "10.nnn.nnn.nnn",
"NodeRole": "COMPUTE-1",
"PublicIPAddress": "10.nnn.nnn.nnn"
}
],
"AutomatedSnapshotRetentionPeriod": 1,
"PreferredMaintenanceWindow": "wed:05:30-wed:06:00",
"AvailabilityZone": "us-east-1a",
"NodeType": "dc2.large",
"ClusterPublicKey": "ssh-rsa AAAABexamplepublickey...Y3TAl Amazon-Redshift",
...
...
}
```
Untuk mengambil kunci publik klaster dan alamat IP node cluster untuk klaster Anda menggunakan Amazon Redshift API, gunakan DescribeClusters tindakan tersebut. Untuk informasi [selengkapnya, lihat deskripsikan klaster](https://docs.aws.amazon.com/cli/latest/reference/redshift/describe-clusters.html) di Panduan *CLI Amazon Redshift atau [DescribeClusters](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html)di Panduan* Amazon Redshift API.
## Langkah 2: Tambahkan kunci publik klaster Amazon Redshift ke file kunci resmi host
Anda menambahkan kunci publik cluster ke file kunci resmi masing-masing host sehingga host akan mengenali Amazon Redshift dan menerima koneksi SSH.
**Untuk menambahkan kunci publik klaster Amazon Redshift ke file kunci resmi host**
1. Akses host menggunakan koneksi SSH.
Untuk informasi tentang menghubungkan ke instans menggunakan SSH, lihat [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-connect-to-instance-linux.html) di Panduan *Pengguna Amazon EC2*.
1. Salin kunci publik Amazon Redshift dari konsol atau dari teks respons CLI.
1. Salin dan tempel konten kunci publik ke dalam `/home//.ssh/authorized_keys` file di host jarak jauh. ``Harus cocok dengan nilai untuk bidang “nama pengguna” di file manifes. Sertakan string lengkap, termasuk awalan "`ssh-rsa`" dan akhiran "”`Amazon-Redshift`. Contoh:
```
ssh-rsa AAAACTP3isxgGzVWoIWpbVvRCOzYdVifMrh… uA70BnMHCaMiRdmvsDOedZDOedZ Amazon-Redshift
```
## Langkah 3: Konfigurasikan host untuk menerima semua alamat IP cluster Amazon Redshift
Jika Anda bekerja dengan instans Amazon EC2 atau kluster EMR Amazon, tambahkan aturan Inbound ke grup keamanan host untuk mengizinkan lalu lintas dari setiap node cluster Amazon Redshift. Untuk **Type**, pilih SSH dengan protokol TCP pada Port 22. Untuk **Sumber**, masukkan alamat IP node cluster Amazon Redshift yang Anda ambil. [Langkah 1: Ambil kunci publik cluster dan alamat IP node cluster](#load-from-host-steps-retrieve-key-and-ips) *Untuk informasi tentang menambahkan aturan ke grup keamanan Amazon EC2, lihat [Mengotorisasi Lalu Lintas Masuk untuk Instans Anda di](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/authorizing-access-to-an-instance.html) Panduan Pengguna Amazon EC2.*
Gunakan alamat IP pribadi saat:
+ Anda memiliki klaster Amazon Redshift yang tidak ada di Virtual Private Cloud (VPC), dan instans Amazon EC2 -Classic, keduanya berada di Wilayah yang sama. AWS
+ Anda memiliki cluster Amazon Redshift yang ada di VPC, dan instans Amazon EC2 -VPC, keduanya berada di Wilayah yang sama dan di VPC yang sama. AWS
Jika tidak, gunakan alamat IP publik.
*Untuk informasi selengkapnya tentang penggunaan Amazon Redshift di VPC, lihat [Mengelola Cluster di Virtual Private Cloud (VPC) di](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-clusters-vpc.html) Panduan Manajemen Amazon Redshift.*
## Langkah 4: Dapatkan kunci publik untuk tuan rumah
Anda dapat memberikan kunci publik host secara opsional dalam file manifes sehingga Amazon Redshift dapat mengidentifikasi host. Perintah COPY tidak memerlukan kunci publik host tetapi, untuk alasan keamanan, kami sangat menyarankan menggunakan kunci publik untuk membantu man-in-the-middle mencegah serangan.
Anda dapat menemukan kunci publik tuan rumah di lokasi berikut, di `` mana nama unik untuk kunci publik tuan rumah:
```
: /etc/ssh/.pub
```
**catatan**
Amazon Redshift hanya mendukung tombol RSA. Kami tidak mendukung kunci DSA.
Saat Anda membuat file manifes di Langkah 5, Anda akan menempelkan teks kunci publik ke bidang “Kunci Publik” di entri file manifes.
## Langkah 5: Buat file manifes
Perintah COPY dapat terhubung ke beberapa host menggunakan SSH, dan dapat membuat beberapa koneksi SSH ke setiap host. COPY menjalankan perintah melalui setiap koneksi host, dan kemudian memuat output dari perintah secara paralel ke dalam tabel. File manifes adalah file teks dalam format JSON yang digunakan Amazon Redshift untuk terhubung ke host. File manifes menentukan titik akhir host SSH dan perintah yang dijalankan pada host untuk mengembalikan data ke Amazon Redshift. Secara opsional, Anda dapat menyertakan kunci publik host, nama pengguna login, dan bendera wajib untuk setiap entri.
Buat file manifes di komputer lokal Anda. Pada langkah selanjutnya, Anda mengunggah file ke Amazon S3.
File manifes dalam format berikut:
```
{
"entries": [
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": ""},
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": "host_user_name"}
]
}
```
File manifes berisi satu konstruksi “entri” untuk setiap koneksi SSH. Setiap entri mewakili koneksi SSH tunggal. Anda dapat memiliki beberapa koneksi ke satu host atau beberapa koneksi ke beberapa host. Tanda kutip ganda diperlukan seperti yang ditunjukkan, baik untuk nama bidang maupun nilainya. Satu-satunya nilai yang tidak memerlukan tanda kutip ganda adalah nilai Boolean **true** atau **false** untuk bidang wajib.
Berikut ini menjelaskan bidang dalam file manifes.
titik akhir
Alamat URL atau alamat IP host. Misalnya, "`ec2-111-222-333.compute-1.amazonaws.com`" atau "`22.33.44.56`”
perintah
Perintah yang akan dijalankan oleh host untuk menghasilkan teks atau biner (gzip, lzop, atau bzip2) output. Perintah dapat berupa perintah apa pun yang pengguna *“host\$1user\$1name”* memiliki izin untuk dijalankan. Perintahnya bisa sesederhana mencetak file, atau bisa menanyakan database atau meluncurkan skrip. Output (file teks, file biner gzip, file biner lzop, atau file biner bzip2) harus dalam bentuk yang dapat dikonsumsi oleh perintah Amazon Redshift COPY. Untuk informasi selengkapnya, lihat [Mempersiapkan data masukan Anda](t_preparing-input-data.md).
kunci publik
(Opsional) Kunci publik tuan rumah. Jika tersedia, Amazon Redshift akan menggunakan kunci publik untuk mengidentifikasi host. Jika kunci publik tidak disediakan, Amazon Redshift tidak akan mencoba identifikasi host. Misalnya, jika kunci publik host jarak jauh adalah:`ssh-rsa AbcCbaxxx…xxxDHKJ root@amazon.com`, masukkan teks berikut di bidang kunci publik:`AbcCbaxxx…xxxDHKJ`.
wajib
(Opsional) Menunjukkan apakah perintah COPY harus gagal jika koneksi gagal. Nilai default-nya `false`. Jika Amazon Redshift tidak berhasil membuat setidaknya satu koneksi, perintah COPY gagal.
nama pengguna
(Opsional) Nama pengguna yang akan digunakan untuk masuk ke sistem host dan menjalankan perintah jarak jauh. Nama login pengguna harus sama dengan login yang digunakan untuk menambahkan kunci publik ke file kunci resmi host di Langkah 2. Nama pengguna default adalah “redshift”.
Contoh berikut menunjukkan manifes lengkap untuk membuka empat koneksi ke host yang sama dan menjalankan perintah yang berbeda melalui setiap koneksi:
```
{
"entries": [
{"endpoint":"ec2-184-72-204-112.compute-1.amazonaws.com",
"command": "cat loaddata1.txt",
"mandatory":true,
"publickey": "ec2publickeyportionoftheec2keypair",
"username": "ec2-user"},
{"endpoint":"ec2-184-72-204-112.compute-1.amazonaws.com",
"command": "cat loaddata2.txt",
"mandatory":true,
"publickey": "ec2publickeyportionoftheec2keypair",
"username": "ec2-user"},
{"endpoint":"ec2-184-72-204-112.compute-1.amazonaws.com",
"command": "cat loaddata3.txt",
"mandatory":true,
"publickey": "ec2publickeyportionoftheec2keypair",
"username": "ec2-user"},
{"endpoint":"ec2-184-72-204-112.compute-1.amazonaws.com",
"command": "cat loaddata4.txt",
"mandatory":true,
"publickey": "ec2publickeyportionoftheec2keypair",
"username": "ec2-user"}
]
}
```
## Langkah 6: Unggah file manifes ke bucket Amazon S3
Unggah file manifes ke bucket Amazon S3. Jika bucket Amazon S3 tidak berada di AWS Wilayah yang sama dengan cluster Amazon Redshift, Anda harus menggunakan [REGION](copy-parameters-data-source-s3.md#copy-region) opsi untuk menentukan AWS Wilayah tempat manifes berada. Untuk informasi tentang membuat bucket Amazon S3 dan mengunggah file, lihat Panduan Pengguna [Layanan Penyimpanan Sederhana Amazon](https://docs.aws.amazon.com/AmazonS3/latest/userguide/).
## Langkah 7: Jalankan perintah COPY untuk memuat data
Jalankan [MENYONTEK](r_COPY.md) perintah untuk menyambung ke host dan memuat data ke dalam tabel Amazon Redshift. Dalam perintah COPY, tentukan jalur objek Amazon S3 eksplisit untuk file manifes dan sertakan opsi SSH. Misalnya,
```
COPY sales
FROM 's3://amzn-s3-demo-bucket/ssh_manifest'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
DELIMITER '|'
SSH;
```
**catatan**
Jika Anda menggunakan kompresi otomatis, perintah COPY melakukan dua pembacaan data, yang berarti menjalankan perintah jarak jauh dua kali. Pembacaan pertama adalah memberikan sampel untuk analisis kompresi, kemudian pembacaan kedua benar-benar memuat data. Jika menjalankan perintah jarak jauh dua kali dapat menyebabkan masalah karena potensi efek samping, Anda harus mematikan kompresi otomatis. Untuk mematikan kompresi otomatis, jalankan perintah COPY dengan opsi COMPUPDATE diatur ke OFF. Untuk informasi selengkapnya, lihat [Memuat tabel dengan kompresi otomatis](c_Loading_tables_auto_compress.md).
# Memuat data dari tabel Amazon DynamoDB
Anda dapat menggunakan perintah COPY untuk memuat tabel dengan data dari satu tabel Amazon DynamoDB.
**penting**
Tabel Amazon DynamoDB yang menyediakan data harus dibuat di Wilayah AWS yang sama dengan klaster Anda kecuali Anda menggunakan opsi untuk menentukan AWS Wilayah [REGION](copy-parameters-data-source-s3.md#copy-region) tempat tabel Amazon DynamoDB berada.
Perintah COPY menggunakan arsitektur Amazon Redshift massively parallel processing (MPP) untuk membaca dan memuat data secara paralel dari tabel Amazon DynamoDB. Anda dapat memanfaatkan pemrosesan paralel secara maksimal dengan menyetel gaya distribusi pada tabel Amazon Redshift Anda. Untuk informasi selengkapnya, lihat [Distribusi data untuk optimasi kueri](t_Distributing_data.md).
**penting**
Saat perintah COPY membaca data dari tabel Amazon DynamoDB, transfer data yang dihasilkan adalah bagian dari throughput yang disediakan tabel tersebut.
Untuk menghindari konsumsi throughput baca yang disediakan dalam jumlah berlebihan, sebaiknya Anda tidak memuat data dari tabel Amazon DynamoDB yang ada di lingkungan produksi. Jika Anda memuat data dari tabel produksi, sebaiknya Anda menyetel opsi READRATIO jauh lebih rendah daripada persentase rata-rata throughput yang tidak digunakan. Pengaturan READRATIO rendah akan membantu meminimalkan masalah pelambatan. Untuk menggunakan seluruh throughput yang disediakan dari tabel Amazon DynamoDB, setel READRATIO ke 100.
Perintah COPY cocok dengan nama atribut dalam item yang diambil dari tabel DynamoDB ke nama kolom dalam tabel Amazon Redshift yang ada menggunakan aturan berikut:
+ Kolom tabel Amazon Redshift secara tidak peka huruf besar/kecil dicocokkan dengan atribut item Amazon DynamoDB. Jika item dalam tabel DynamoDB berisi beberapa atribut yang hanya berbeda dalam kasus, seperti Harga dan HARGA, perintah COPY akan gagal.
+ Kolom tabel Amazon Redshift yang tidak cocok dengan atribut dalam tabel Amazon DynamoDB dimuat sebagai NULL atau kosong, tergantung pada nilai yang ditentukan dengan opsi EMPTYASNULL dalam perintah. [MENYONTEK](r_COPY.md)
+ Atribut Amazon DynamoDB yang tidak cocok dengan kolom di tabel Amazon Redshift dibuang. Atribut dibaca sebelum dicocokkan, dan bahkan atribut yang dibuang menggunakan bagian dari throughput yang disediakan tabel itu.
+ Hanya atribut Amazon DynamoDB dengan tipe data STRING dan NUMBER skalar yang didukung. Jenis data Amazon DynamoDB BINARY dan SET tidak didukung. Jika perintah COPY mencoba memuat atribut dengan tipe data yang tidak didukung, perintah akan gagal. Jika atribut tidak cocok dengan kolom tabel Amazon Redshift, COPY tidak mencoba memuatnya, dan tidak menimbulkan kesalahan.
Perintah COPY menggunakan sintaks berikut untuk memuat data dari tabel Amazon DynamoDB:
```
COPY FROM 'dynamodb://'
authorization
readratio '';
```
Nilai untuk *otorisasi* adalah AWS kredensional yang diperlukan untuk mengakses tabel Amazon DynamoDB. Jika kredensil ini sesuai dengan pengguna, pengguna tersebut harus memiliki izin untuk MEMINDAI dan MENDESKRIPSIKAN tabel Amazon DynamoDB yang sedang dimuat.
Nilai untuk *otorisasi memberikan otorisasi* yang AWS dibutuhkan klaster Anda untuk mengakses tabel Amazon DynamoDB. Izin harus menyertakan SCAN dan DESCRIPTION untuk tabel Amazon DynamoDB yang sedang dimuat. Untuk informasi lebih lanjut tentang izin yang diperlukan, lihat [Izin IAM untuk COPY, UNLOAD, dan CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions). Metode yang lebih disukai untuk otentikasi adalah menentukan parameter IAM\$1ROLE dan memberikan Amazon Resource Name (ARN) untuk peran IAM dengan izin yang diperlukan. Untuk informasi selengkapnya, lihat [Kontrol akses berbasis peran](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
Untuk mengautentikasi menggunakan parameter IAM\$1ROLE, ** dan ** seperti yang ditunjukkan dalam sintaks berikut.
```
IAM_ROLE 'arn:aws:iam:::role/'
```
Contoh berikut menunjukkan otentikasi menggunakan peran IAM.
```
COPY favoritemovies
FROM 'dynamodb://ProductCatalog'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Untuk informasi selengkapnya tentang opsi otorisasi lainnya, lihat [Parameter otorisasi](copy-parameters-authorization.md)
Jika Anda ingin memvalidasi data Anda tanpa benar-benar memuat tabel, gunakan opsi NOLOAD dengan perintah. [MENYONTEK](r_COPY.md)
Contoh berikut memuat tabel FAVORITEMOVIES dengan data dari tabel DynamoDB. my-favorite-movies-table Aktivitas membaca dapat mengkonsumsi hingga 50% dari throughput yang disediakan.
```
COPY favoritemovies FROM 'dynamodb://my-favorite-movies-table'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
READRATIO 50;
```
Untuk memaksimalkan throughput, perintah COPY memuat data dari tabel Amazon DynamoDB secara paralel di seluruh node komputasi di cluster.
## Throughput yang disediakan dengan kompresi otomatis
Secara default, perintah COPY menerapkan kompresi otomatis setiap kali Anda menentukan tabel target kosong tanpa pengkodean kompresi. Analisis kompresi otomatis awalnya mengambil sampel sejumlah besar baris dari tabel Amazon DynamoDB. Ukuran sampel didasarkan pada nilai parameter COMPROWS. Defaultnya adalah 100.000 baris per irisan.
Setelah pengambilan sampel, baris sampel dibuang dan seluruh tabel dimuat. Akibatnya, banyak baris dibaca dua kali. Untuk informasi selengkapnya tentang cara kerja kompresi otomatis, lihat[Memuat tabel dengan kompresi otomatis](c_Loading_tables_auto_compress.md).
**penting**
Saat perintah COPY membaca data dari tabel Amazon DynamoDB, termasuk baris yang digunakan untuk pengambilan sampel, transfer data yang dihasilkan adalah bagian dari throughput yang disediakan tabel tersebut.
## Memuat data multibyte dari Amazon DynamoDB
Jika data Anda menyertakan karakter multibyte non-ASCII (seperti karakter Mandarin atau Sirilik), Anda harus memuat data ke kolom VARCHAR. Tipe data VARCHAR mendukung karakter UTF-8 empat byte, tetapi tipe data CHAR hanya menerima karakter ASCII single-byte. Anda tidak dapat memuat karakter lima byte atau lebih panjang ke dalam tabel Amazon Redshift. Untuk informasi lebih lanjut tentang CHAR dan VARCHAR, lihat. [Jenis Data](c_Supported_data_types.md)
# Memverifikasi bahwa data dimuat dengan benar
Setelah operasi pemuatan selesai, kueri tabel [STL\$1LOAD\$1COMMIT](r_STL_LOAD_COMMITS.md) sistem untuk memverifikasi bahwa file yang diharapkan dimuat. Jalankan perintah COPY dan muat verifikasi dalam transaksi yang sama sehingga jika ada masalah dengan beban Anda dapat memutar kembali seluruh transaksi.
Kueri berikut mengembalikan entri untuk memuat tabel dalam database TICKIT:
```
SELECT query, trim(filename) AS filename, curtime, status
FROM stl_load_commits
WHERE filename like '%tickit%' order by query;
query | filename | curtime | status
-------+---------------------------+----------------------------+--------
22475 | tickit/allusers_pipe.txt | 2013-02-08 20:58:23.274186 | 1
22478 | tickit/venue_pipe.txt | 2013-02-08 20:58:25.070604 | 1
22480 | tickit/category_pipe.txt | 2013-02-08 20:58:27.333472 | 1
22482 | tickit/date2008_pipe.txt | 2013-02-08 20:58:28.608305 | 1
22485 | tickit/allevents_pipe.txt | 2013-02-08 20:58:29.99489 | 1
22487 | tickit/listings_pipe.txt | 2013-02-08 20:58:37.632939 | 1
22489 | tickit/sales_tab.txt | 2013-02-08 20:58:37.632939 | 1
(6 rows)
```
# Memvalidasi data masukan
Untuk memvalidasi data dalam file input Amazon S3 atau tabel Amazon DynamoDB sebelum Anda benar-benar memuat data, gunakan opsi NOLOAD dengan perintah. [MENYONTEK](r_COPY.md) Gunakan NOLOAD dengan perintah dan opsi COPY yang sama yang akan Anda gunakan untuk memuat data. NOLOAD memeriksa integritas semua data tanpa memuatnya ke dalam database. Opsi NOLOAD menampilkan kesalahan apa pun yang terjadi jika Anda mencoba memuat data.
Misalnya, jika Anda menentukan jalur Amazon S3 yang salah untuk file input, Amazon Redshift akan menampilkan kesalahan berikut.
```
ERROR: No such file or directory
DETAIL:
-----------------------------------------------
Amazon Redshift error: The specified key does not exist
code: 2
context: S3 key being read :
location: step_scan.cpp:1883
process: xenmaster [pid=22199]
-----------------------------------------------
```
Untuk memecahkan masalah pesan kesalahan, lihat. [Referensi kesalahan muat](r_Load_Error_Reference.md)
Untuk contoh menggunakan opsi NOLOAD, lihat[COPY perintah dengan opsi NOLOAD](r_COPY_command_examples.md#r_COPY_command_examples-load-noload-option).
# Memuat tabel dengan kompresi otomatis
Anda dapat menerapkan pengkodean kompresi ke kolom dalam tabel secara manual, berdasarkan evaluasi data Anda sendiri. Atau Anda dapat menggunakan perintah COPY dengan COMPUPDATE diatur ke ON untuk menganalisis dan menerapkan kompresi secara otomatis berdasarkan data sampel.
Anda dapat menggunakan kompresi otomatis saat membuat dan memuat tabel baru. Perintah COPY melakukan analisis kompresi. Anda juga dapat melakukan analisis kompresi tanpa memuat data atau mengubah kompresi pada tabel dengan menjalankan [MENGANALISIS KOMPRESI](r_ANALYZE_COMPRESSION.md) perintah pada tabel yang sudah diisi. Misalnya, Anda dapat menjalankan ANALYSIS COMPRESSION ketika Anda ingin menganalisis kompresi pada tabel untuk penggunaan di masa mendatang, sambil mempertahankan pernyataan bahasa definisi data (DDL) yang ada.
Kompresi otomatis menyeimbangkan kinerja keseluruhan saat memilih pengkodean kompresi. Pemindaian terbatas rentang mungkin berkinerja buruk jika kolom kunci pengurutan dikompresi jauh lebih tinggi daripada kolom lain dalam kueri yang sama. Akibatnya, kompresi otomatis melewatkan fase analisis data pada kolom kunci sortir dan mempertahankan jenis pengkodean yang ditentukan pengguna.
Kompresi otomatis memilih pengkodean RAW jika Anda belum secara eksplisit mendefinisikan jenis pengkodean. ANALISIS KOMPRESI berperilaku sama. Untuk kinerja kueri yang optimal, pertimbangkan untuk menggunakan RAW untuk kunci pengurutan.
## Cara kerja kompresi otomatis
Ketika parameter COMPUPDATE AKTIF, perintah COPY menerapkan kompresi otomatis setiap kali Anda menjalankan perintah COPY dengan tabel target kosong dan semua kolom tabel memiliki pengkodean RAW atau tidak ada pengkodean.
Untuk menerapkan kompresi otomatis ke tabel kosong, terlepas dari pengkodean kompresi saat ini, jalankan perintah COPY dengan opsi COMPUPDATE diatur ke ON. Untuk mematikan kompresi otomatis, jalankan perintah COPY dengan opsi COMPUPDATE diatur ke OFF.
Anda tidak dapat menerapkan kompresi otomatis ke tabel yang sudah berisi data.
**catatan**
Analisis kompresi otomatis membutuhkan baris yang cukup dalam data beban (setidaknya 100.000 baris per irisan) untuk menghasilkan sampel yang bermakna.
Kompresi otomatis melakukan operasi ini di latar belakang sebagai bagian dari transaksi beban:
1. Sampel awal baris dimuat dari file input. Ukuran sampel didasarkan pada nilai parameter COMPROWS. Defaultnya adalah 100.000.
1. Opsi kompresi dipilih untuk setiap kolom.
1. Baris sampel dihapus dari tabel.
1. Tabel dibuat ulang dengan pengkodean kompresi yang dipilih.
1. Seluruh file input dimuat dan dikompresi menggunakan pengkodean baru.
Setelah Anda menjalankan perintah COPY, tabel dimuat penuh, dikompresi, dan siap digunakan. Jika Anda memuat lebih banyak data nanti, baris yang ditambahkan dikompresi sesuai dengan pengkodean yang ada.
Jika Anda hanya ingin melakukan analisis kompresi, jalankan ANALYZE COMPRESSION, yang lebih efisien daripada menjalankan COPY lengkap. Kemudian Anda dapat mengevaluasi hasilnya untuk memutuskan apakah akan menggunakan kompresi otomatis atau membuat ulang tabel secara manual.
Kompresi otomatis hanya didukung untuk perintah COPY. Atau, Anda dapat menerapkan pengkodean kompresi secara manual saat membuat tabel. Untuk informasi tentang pengkodean kompresi manual, lihat[Kompresi kolom untuk mengurangi ukuran data yang disimpan](t_Compressing_data_on_disk.md).
## Contoh kompresi otomatis
Dalam contoh ini, asumsikan bahwa database TICKIT berisi salinan tabel LISTING yang disebut BIGLIST, dan Anda ingin menerapkan kompresi otomatis ke tabel ini ketika dimuat dengan sekitar 3 juta baris.
**Untuk memuat dan secara otomatis mengompres tabel**
1. Pastikan meja kosong. Anda dapat menerapkan kompresi otomatis hanya ke tabel kosong:
```
TRUNCATE biglist;
```
1. Muat tabel dengan satu perintah COPY. Meskipun tabel kosong, beberapa pengkodean sebelumnya mungkin telah ditentukan. Untuk memfasilitasi Amazon Redshift melakukan analisis kompresi, atur parameter COMPUPDATE ke ON.
```
COPY biglist FROM 's3://amzn-s3-demo-bucket/biglist.txt'
IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
DELIMITER '|' COMPUPDATE ON;
```
Karena tidak ada opsi COMPROWS yang ditentukan, ukuran sampel default dan yang direkomendasikan 100.000 baris per irisan digunakan.
1. Lihatlah skema baru untuk tabel BIGLIST untuk meninjau skema pengkodean yang dipilih secara otomatis.
```
SELECT "column", type, encoding
from pg_table_def where tablename = 'biglist';
Column | Type | Encoding
----------------+-----------------------------+----------
listid | integer | az64
sellerid | integer | az64
eventid | integer | az64
dateid | smallint | none
numtickets | smallint | az64
priceperticket | numeric(8,2) | az64
totalprice | numeric(8,2) | az64
listtime | timestamp without time zone | az64
```
1. Verifikasi bahwa jumlah baris yang diharapkan dimuat:
```
select count(*) from biglist;
count
---------
3079952
(1 row)
```
Ketika baris kemudian ditambahkan ke tabel ini menggunakan pernyataan COPY atau INSERT, pengkodean kompresi yang sama diterapkan.
# Mengoptimalkan penyimpanan untuk tabel sempit
Jika Anda memiliki tabel dengan sangat sedikit kolom tetapi jumlah baris yang sangat besar, tiga kolom identitas metadata tersembunyi (INSERT\$1XID, DELETE\$1XID, ROW\$1ID) akan mengkonsumsi jumlah ruang disk yang tidak proporsional untuk tabel.
Untuk mengoptimalkan kompresi kolom tersembunyi, muat tabel dalam satu transaksi COPY jika memungkinkan. Jika Anda memuat tabel dengan beberapa perintah COPY terpisah, kolom INSERT\$1XID tidak akan terkompres dengan baik. Anda harus melakukan operasi vakum jika Anda menggunakan beberapa perintah COPY, tetapi itu tidak akan meningkatkan kompresi INSERT\$1XID.
# Memuat nilai kolom default
Anda dapat secara opsional menentukan daftar kolom dalam perintah COPY Anda. Jika kolom dalam tabel dihilangkan dari daftar kolom, COPY akan memuat kolom dengan nilai yang diberikan oleh opsi DEFAULT yang ditentukan dalam perintah CREATE TABLE, atau dengan NULL jika opsi DEFAULT tidak ditentukan.
Jika COPY mencoba untuk menetapkan NULL ke kolom yang didefinisikan sebagai NOT NULL, perintah COPY gagal. Untuk informasi tentang menetapkan opsi DEFAULT, lihat[CREATE TABLE](r_CREATE_TABLE_NEW.md).
Saat memuat dari file data di Amazon S3, kolom dalam daftar kolom harus dalam urutan yang sama dengan bidang dalam file data. Jika bidang dalam file data tidak memiliki kolom yang sesuai dalam daftar kolom, perintah COPY gagal.
Saat memuat dari tabel Amazon DynamoDB, pesanan tidak masalah. Bidang apa pun di atribut Amazon DynamoDB yang tidak cocok dengan kolom di tabel Amazon Redshift akan dibuang.
Pembatasan berikut berlaku saat menggunakan perintah COPY untuk memuat nilai DEFAULT ke dalam tabel:
+ Jika [IDENTITY](r_CREATE_TABLE_NEW.md#identity-clause) kolom disertakan dalam daftar kolom, opsi EXPLICIT\$1IDS juga harus ditentukan dalam [MENYONTEK](r_COPY.md) perintah, atau perintah COPY akan gagal. Demikian pula, jika kolom IDENTITY dihilangkan dari daftar kolom, dan opsi EXPLICIT\$1IDS ditentukan, operasi COPY akan gagal.
+ Karena ekspresi DEFAULT yang dievaluasi untuk kolom tertentu adalah sama untuk semua baris yang dimuat, ekspresi DEFAULT yang menggunakan fungsi RANDOM () akan menetapkan nilai yang sama ke semua baris.
+ Ekspresi DEFAULT yang berisi CURRENT\$1DATE atau SYSDATE diatur ke stempel waktu transaksi saat ini.
Sebagai contoh, lihat “Memuat data dari file dengan nilai default” di[Contoh COPY](r_COPY_command_examples.md).
# Memecahkan masalah beban data
Saat memuat data ke tabel Amazon Redshift, Anda mungkin mengalami kesalahan dari Amazon S3, data input tidak valid, dan kesalahan perintah COPY. Bagian berikut memberikan informasi tentang mengidentifikasi dan menyelesaikan kesalahan pemuatan data.
**Topics**
+ [Memecahkan masalah integrasi acara S3 dan kesalahan COPY JOB](s3-integration-troubleshooting.md)
+ [Kesalahan S3 ServiceException](s3serviceexception-error.md)
+ [Tabel sistem untuk memecahkan masalah beban data](system-tables-for-troubleshooting-data-loads.md)
+ [Kesalahan pemuatan karakter multibyte](multi-byte-character-load-errors.md)
+ [Referensi kesalahan muat](r_Load_Error_Reference.md)
# Memecahkan masalah integrasi acara S3 dan kesalahan COPY JOB
Gunakan informasi berikut untuk memecahkan masalah umum dengan integrasi acara Amazon S3 dan COPY JOB dengan Amazon Redshift.
## Pembuatan integrasi acara S3 gagal
Jika pembuatan integrasi acara S3 gagal, status integrasinya adalah`Inactive`. Pastikan bahwa berikut ini benar untuk gudang data Amazon Redshift Anda.
+ Anda menambahkan sumber utama dan integrasi resmi yang benar untuk namespace target Anda di Amazon Redshift. Lihat [Prasyarat untuk membuat integrasi acara S3](loading-data-copy-job.md#loading-data-copy-job-prerequisites).
+ Anda menambahkan kebijakan berbasis sumber daya yang benar ke bucket Amazon S3 sumber. Lihat [Prasyarat untuk membuat integrasi acara S3](loading-data-copy-job.md#loading-data-copy-job-prerequisites).
## Data Amazon S3 Anda tidak muncul di database target
Jika data dari COPY JOB tidak muncul, periksa berikut ini.
+ Kueri SYS\$1COPY\$1JOB\$1DETAIL untuk melihat apakah file Amazon S3 telah dimuat, apakah konsumsi yang tertunda, atau ada kesalahan. Untuk informasi selengkapnya, lihat [SYS\$1COPY\$1JOB\$1DETAIL](SYS_COPY_JOB_DETAIL.md).
+ Konsultasikan STL\$1ERROR atau SYS\$1COPY\$1JOB\$1INFO jika file Amazon S3 tidak ada atau ada waktu tunggu yang tidak terduga. Cari kesalahan kredensi atau apa pun yang menunjukkan bahwa integrasi tidak aktif. Untuk informasi selengkapnya, lihat [STL\$1ERROR](r_STL_ERROR.md) dan [SYS\$1COPY\$1JOB\$1INFO](SYS_COPY_JOB_INFO.md).
# Kesalahan S3 ServiceException
ServiceException Kesalahan s3 yang paling umum disebabkan oleh string kredensyal yang diformat dengan tidak benar atau salah, klaster dan bucket Anda berada di Wilayah yang berbeda AWS , serta izin Amazon S3 yang tidak mencukupi.
Bagian ini menyediakan informasi pemecahan masalah untuk setiap jenis kesalahan.
## String kredensial tidak valid
Jika string kredensil Anda tidak diformat dengan benar, Anda akan menerima pesan galat berikut:
```
ERROR: Invalid credentials. Must be of the format: credentials
'aws_access_key_id=;aws_secret_access_key=
[;token=]'
```
Verifikasi bahwa string kredensil tidak mengandung spasi atau jeda baris, dan diapit dalam tanda kutip tunggal.
## ID kunci akses tidak valid
Jika ID kunci akses Anda tidak ada, Anda akan menerima pesan galat berikut:
```
[Amazon](500310) Invalid operation: S3ServiceException:The AWS Access Key Id you provided does not exist in our records.
```
Ini sering merupakan kesalahan salin dan tempel. Verifikasi bahwa ID kunci akses telah dimasukkan dengan benar. Juga, jika Anda menggunakan kunci sesi sementara, periksa apakah nilai untuk `token` disetel.
## Kunci akses rahasia tidak valid
Jika kunci akses rahasia Anda salah, Anda akan menerima pesan galat berikut:
```
[Amazon](500310) Invalid operation: S3ServiceException:The request signature we calculated does not match the signature you provided.
Check your key and signing method.,Status 403,Error SignatureDoesNotMatch
```
Ini sering merupakan kesalahan salin dan tempel. Verifikasi bahwa kunci akses rahasia dimasukkan dengan benar dan itu adalah kunci yang benar untuk ID kunci akses.
## Bucket berada di Wilayah yang berbeda
Bucket Amazon S3 yang ditentukan dalam perintah COPY harus berada di AWS Wilayah yang sama dengan cluster. Jika bucket Amazon S3 dan kluster Anda berada di Wilayah yang berbeda, Anda akan menerima kesalahan yang mirip dengan berikut ini:
```
ERROR: S3ServiceException:The bucket you are attempting to access must be addressed using the specified endpoint.
```
Anda dapat membuat bucket Amazon S3 di Wilayah tertentu baik dengan memilih Wilayah saat membuat bucket menggunakan Konsol Manajemen Amazon S3, atau dengan menentukan titik akhir saat membuat bucket menggunakan Amazon S3 API atau CLI. Untuk informasi selengkapnya, lihat [Mengunggah file ke Amazon S3 untuk digunakan dengan COPY](t_uploading-data-to-S3.md).
Untuk informasi selengkapnya tentang wilayah Amazon S3, lihat [Mengakses Bucket di Panduan](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html#access-bucket-intro) Pengguna *Layanan Penyimpanan Sederhana Amazon*.
Atau, Anda dapat menentukan Wilayah menggunakan [REGION](copy-parameters-data-source-s3.md#copy-region) opsi dengan perintah COPY.
## Akses ditolak
Jika pengguna tidak memiliki izin yang memadai, Anda akan menerima pesan galat berikut:
```
ERROR: S3ServiceException:Access Denied,Status 403,Error AccessDenied
```
Salah satu kemungkinan penyebabnya adalah pengguna yang diidentifikasi oleh kredensialnya tidak memiliki LIST dan GET akses ke bucket Amazon S3. Untuk penyebab lainnya, lihat [Memecahkan masalah kesalahan Akses Ditolak (403 Terlarang) di Amazon S3 di Panduan Pengguna](https://docs.aws.amazon.com/AmazonS3/latest/userguide/troubleshoot-403-errors.html) Layanan Penyimpanan *Sederhana Amazon*.
Untuk informasi tentang mengelola akses pengguna ke bucket, lihat [Manajemen identitas dan akses di Amazon](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html) S3 di Panduan Pengguna *Layanan Penyimpanan Sederhana Amazon*.
# Tabel sistem untuk memecahkan masalah beban data
Tabel sistem Amazon Redshift berikut dapat membantu dalam memecahkan masalah pemuatan data:
+ Kueri [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md) untuk menemukan kesalahan yang terjadi selama pemuatan tertentu.
+ Kueri [STL\$1FILE\$1SCAN](r_STL_FILE_SCAN.md) untuk melihat waktu muat untuk file tertentu atau untuk melihat apakah file tertentu bahkan dibaca.
+ Kueri [STL\$1S3CLIENT\$1ERROR](r_STL_S3CLIENT_ERROR.md) untuk menemukan detail untuk kesalahan yang ditemui saat mentransfer data dari Amazon S3.
**Untuk menemukan dan mendiagnosis kesalahan beban**
1. Buat tampilan atau tentukan kueri yang mengembalikan detail tentang kesalahan pemuatan. Contoh berikut menggabungkan tabel STL\$1LOAD\$1ERRORS ke tabel STV\$1TBL\$1PERM untuk mencocokkan tabel dengan nama tabel yang sebenarnya. IDs
```
create view loadview as
(select distinct tbl, trim(name) as table_name, query, starttime,
trim(filename) as input, line_number, colname, err_code,
trim(err_reason) as reason
from stl_load_errors sl, stv_tbl_perm sp
where sl.tbl = sp.id);
```
1. Setel opsi MAXERRORS dalam perintah COPY Anda ke nilai yang cukup besar untuk mengaktifkan COPY untuk mengembalikan informasi yang berguna tentang data Anda. Jika COPY menemukan kesalahan, pesan kesalahan mengarahkan Anda untuk melihat tabel STL\$1LOAD\$1ERRORS untuk detailnya.
1. Kueri tampilan LOADVIEW untuk melihat detail kesalahan. Contoh:
```
select * from loadview where table_name='venue';
```
```
tbl | table_name | query | starttime
--------+------------+-------+----------------------------
100551 | venue | 20974 | 2013-01-29 19:05:58.365391
| input | line_number | colname | err_code | reason
+----------------+-------------+---------+----------+--------------------
| venue_pipe.txt | 1 | 0 | 1214 | Delimiter not found
```
1. Perbaiki masalah dalam file input atau skrip pemuatan, berdasarkan informasi yang dikembalikan tampilan. Beberapa kesalahan pemuatan khas yang harus diperhatikan meliputi:
+ Ketidakcocokan antara tipe data dalam tabel dan nilai di bidang data input.
+ Ketidakcocokan antara jumlah kolom dalam tabel dan jumlah bidang dalam data input.
+ Tanda kutip yang tidak cocok. Amazon Redshift mendukung tanda kutip tunggal dan ganda; Namun, tanda kutip ini harus diseimbangkan dengan tepat.
+ Format date/time data yang salah dalam file input.
+ Out-of-range nilai dalam file input (untuk kolom numerik).
+ Jumlah nilai yang berbeda untuk kolom melebihi batasan untuk pengkodean kompresi.
# Kesalahan pemuatan karakter multibyte
Kolom dengan tipe data CHAR hanya menerima karakter UTF-8 byte tunggal, hingga nilai byte 127, atau 7F hex, yang juga merupakan kumpulan karakter ASCII. Kolom VARCHAR menerima karakter multibyte UTF-8, hingga maksimal empat byte. Untuk informasi selengkapnya, lihat [Jenis karakter](r_Character_types.md).
Jika baris dalam data pemuatan Anda berisi karakter yang tidak valid untuk tipe data kolom, COPY mengembalikan kesalahan dan mencatat baris dalam tabel log sistem STL\$1LOAD\$1ERRORS dengan nomor kesalahan 1220. Bidang ERR\$1REASON menyertakan urutan byte, dalam hex, untuk karakter yang tidak valid.
Alternatif untuk memperbaiki karakter yang tidak valid dalam data pemuatan Anda adalah dengan mengganti karakter yang tidak valid selama proses pemuatan. Untuk mengganti karakter UTF-8 yang tidak valid, tentukan opsi ACCEPTINVCHARS dengan perintah COPY. Jika opsi ACCEPTINVCHARS diatur, karakter yang Anda tentukan menggantikan titik kode. Jika opsi ACCEPTINVCHARS tidak disetel, Amazon Redshift menerima karakter sebagai UTF-8 yang valid. Untuk informasi selengkapnya, lihat [ACCEPTINVCHARS](copy-parameters-data-conversion.md#acceptinvchars).
Daftar poin kode berikut adalah UTF-8 yang valid, operasi COPY tidak mengembalikan kesalahan jika opsi ACCEPTINVCHARS tidak disetel. Namun, poin kode ini bukan karakter yang valid. Anda dapat menggunakan [ACCEPTINVCHARS](copy-parameters-data-conversion.md#acceptinvchars) opsi untuk mengganti titik kode dengan karakter yang Anda tentukan. Poin kode ini mencakup rentang nilai dari `0xFDD0` ke `0xFDEF` dan nilai hingga`0x10FFFF`, diakhiri dengan `FFFE` atau`FFFF`:
+ `0xFFFE`, `0x1FFFE`, `0x2FFFE`, …, `0xFFFFE`, `0x10FFFE`
+ `0xFFFF`, `0x1FFFF`, `0x2FFFF`, …, `0xFFFFF`, `0x10FFFF`
Contoh berikut menunjukkan alasan kesalahan ketika COPY mencoba untuk memuat karakter UTF-8 `e0 a1 c7a4` ke dalam kolom CHAR.
```
Multibyte character not supported for CHAR
(Hint: Try using VARCHAR). Invalid char: e0 a1 c7a4
```
Jika kesalahan terkait dengan tipe data VARCHAR, alasan kesalahan mencakup kode kesalahan serta urutan hex UTF-8 yang tidak valid. Contoh berikut menunjukkan alasan kesalahan saat COPY mencoba memuat UTF-8 `a4` ke dalam bidang VARCHAR.
```
String contains invalid or unsupported UTF-8 codepoints.
Bad UTF-8 hex sequence: a4 (error 3)
```
Tabel berikut mencantumkan deskripsi dan solusi yang disarankan untuk kesalahan pemuatan VARCHAR. Jika salah satu kesalahan ini terjadi, ganti karakter dengan urutan kode UTF-8 yang valid atau hapus karakter.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/multi-byte-character-load-errors.html)
# Referensi kesalahan muat
Jika terjadi kesalahan saat memuat data dari file, kueri [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md) tabel untuk mengidentifikasi kesalahan dan menentukan penjelasan yang mungkin. Tabel berikut mencantumkan semua kode kesalahan yang mungkin terjadi selama pemuatan data:
## Memuat kode kesalahan
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/r_Load_Error_Reference.html)
# Buat integrasi acara S3 untuk menyalin file secara otomatis dari bucket Amazon S3
**catatan**
Rilis pratinjau untuk salinan otomatis telah berakhir. Akibatnya, klaster pratinjau akan dihapus secara otomatis 30 hari setelah akhir periode pratinjau. Jika Anda berencana untuk terus menggunakan penyalinan otomatis, sebaiknya buat ulang pekerjaan penyalinan otomatis yang ada di klaster Amazon Redshift lainnya. Memutakhirkan klaster pratinjau ke versi Amazon Redshift terbaru tidak didukung.
Anda dapat menggunakan pekerjaan salin otomatis untuk memuat data ke tabel Amazon Redshift dari file yang disimpan di Amazon S3. Amazon Redshift mendeteksi kapan file Amazon S3 baru ditambahkan ke jalur yang ditentukan dalam perintah COPY Anda. Perintah COPY kemudian dijalankan secara otomatis tanpa Anda harus membuat pipeline konsumsi data eksternal. Amazon Redshift melacak file mana yang telah dimuat. Amazon Redshift menentukan jumlah file yang dikumpulkan bersama per perintah COPY. Anda dapat melihat perintah COPY yang dihasilkan dalam tampilan sistem.
Langkah pertama untuk membuat COPY JOB otomatis adalah membuat integrasi acara S3. Saat file baru muncul di bucket sumber Amazon S3, Amazon Redshift kemudian mengelola pemuatan file ke database Anda menggunakan perintah COPY.
## Prasyarat untuk membuat integrasi acara S3
Untuk mengatur integrasi acara s3 Anda, konfirmasikan prasyarat berikut telah selesai.
+ Bucket Amazon S3 Anda harus memiliki kebijakan bucket yang memungkinkan beberapa izin Amazon S3. Misalnya, kebijakan contoh berikut mengizinkan izin untuk bucket sumber daya `amzn-s3-demo-bucket` yang di-host. *us-east-1* Baik bucket Amazon S3 dan integrasinya sama. Wilayah AWS
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Auto-Copy-Policy-01",
"Effect": "Allow",
"Principal": {
"Service": "redshift.amazonaws.com"
},
"Action": [
"s3:GetBucketNotification",
"s3:PutBucketNotification",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket:*",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:redshift:us-east-1:111122223333:integration:*"
},
"StringEquals": {
"aws:SourceAccount": "111122223333"
}
}
}
]
}
```
------
+ Cluster yang disediakan Amazon Redshift target atau namespace Tanpa Server Redshift Anda harus memiliki izin ke bucket. Konfirmasikan peran IAM yang terkait dengan cluster atau ruang nama tanpa server Anda memiliki kebijakan IAM yang memungkinkan izin yang tepat. Kebijakan harus mengizinkan sumber daya bucket seperti `amzn-s3-demo-bucket` dan `s3:ListBucket` untuk sumber daya bucket dan isinya seperti`amzn-s3-demo-bucket/*`. `s3:GetObject`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AutoCopyReadId",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}
```
------
Tambahkan kebijakan Anda ke peran IAM yang memiliki hubungan kepercayaan untuk peran tersebut adalah sebagai berikut.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"redshift.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Jika gudang data target Anda adalah klaster yang disediakan, Anda dapat mengaitkan peran IAM ke kluster yang disediakan menggunakan konsol Amazon Redshift, tab izin Cluster di detail **klaster** Anda. *Untuk informasi tentang cara mengaitkan peran ke kluster yang disediakan, lihat [Mengaitkan peran IAM dengan klaster di](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role-associating-with-clusters.html) Panduan Manajemen Pergeseran Merah Amazon.*
**Jika gudang data target Anda adalah Redshift Serverless, Anda dapat mengaitkan peran IAM ke namespace tanpa server menggunakan konsol Redshift Serverless, tab Keamanan, dan enkripsi di detail namespace Anda.** *Untuk informasi tentang cara mengaitkan peran ke namespace tanpa server, lihat [Memberikan izin ke Amazon Redshift Tanpa Server di Panduan Manajemen Pergeseran Merah Amazon](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-security-other-services.html).*
+ Gudang data Amazon Redshift Anda juga harus memiliki kebijakan sumber daya yang memungkinkan bucket Amazon S3. Jika Anda menggunakan konsol Amazon Redshift, saat Anda membuat integrasi acara s3, Amazon Redshift menyediakan opsi **Perbaiki agar saya menambahkan kebijakan ini ke gudang** data Amazon Redshift Anda. Untuk memperbarui kebijakan sumber daya sendiri, Anda dapat menggunakan [put-resource-policy](https://docs.aws.amazon.com/cli/latest/reference/redshift/put-resource-policy.html) AWS CLI perintah. Misalnya, untuk melampirkan kebijakan sumber daya ke kluster yang disediakan Amazon Redshift untuk integrasi peristiwa S3 dengan bucket Amazon S3, jalankan perintah yang serupa dengan berikut ini. AWS CLI Contoh berikut menunjukkan kebijakan untuk namespace klaster yang disediakan di akun untuk pengguna. *us-east-1* Wilayah AWS *123456789012* Ember itu diberi nama*amzn-s3-demo-bucket*.
```
aws redshift put-resource-policy \
--policy file://rs-rp.json \
--resource-arn "arn:aws:redshift: us-east-1:123456789012:namespace/cc4ffe56-ad2c-4fd1-a5a2-f29124a56433"
```
Di mana `rs-rp.json` berisi:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "redshift.amazonaws.com"
},
"Action": "redshift:AuthorizeInboundIntegration",
"Resource": "arn:aws:redshift:us-east-1:123456789012:namespace:cc4ffe56-ad2c-4fd1-a5a2-f29124a56433",
"Condition": {
"StringEquals": {
"aws:SourceArn": "arn:aws:s3:::amzn-s3-demo-bucket",
"aws:SourceAccount": 111122223333
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/myRedshiftRole"
},
"Action": "redshift:CreateInboundIntegration",
"Resource": "arn:aws:redshift:us-east-1:123456789012:namespace:cc4ffe56-ad2c-4fd1-a5a2-f29124a56433",
"Condition": {
"StringEquals": {
"aws:SourceArn": "arn:aws:s3:::amzn-s3-demo-bucket",
"aws:SourceAccount": 111122223333
}
}
}
]
}
```
------
Untuk melampirkan kebijakan sumber daya ke namespace Redshift Tanpa Server Anda untuk integrasi peristiwa S3 dengan bucket Amazon S3, jalankan perintah yang serupa dengan berikut ini. AWS CLI Contoh berikut menunjukkan kebijakan untuk namespace tanpa server di akun untuk pengguna. *us-east-1* Wilayah AWS *123456789012* Ember itu diberi nama*amzn-s3-demo-bucket*.
```
aws redshift put-resource-policy \
--policy file://rs-rp.json \
--resource-arn "arn:aws:redshift-serverless:us-east-1:123456789012:namespace/namespace-1"
```
Di mana `rs-rp.json` berisi:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "redshift.amazonaws.com"
},
"Action": "redshift:AuthorizeInboundIntegration",
"Resource": "arn:aws:redshift-serverless:us-east-1:123456789012:namespace/namespace-1",
"Condition": {
"StringEquals": {
"aws:SourceArn": "arn:aws:s3:::amzn-s3-demo-bucket",
"aws:SourceAccount": 111122223333
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/myUser"
},
"Action": "redshift:CreateInboundIntegration",
"Resource": "arn:aws:redshift-serverless:us-east-1:123456789012:namespace/namespace-1",
"Condition": {
"StringEquals": {
"aws:SourceArn": "arn:aws:s3:::amzn-s3-demo-bucket",
"aws:SourceAccount": 111122223333
}
}
}
]
}
```
------
## Buat integrasi acara S3
Untuk menyiapkan pekerjaan penyalinan Anda, pertama-tama Anda menentukan integrasi acara S3.
------
#### [ Amazon Redshift console ]
**Untuk membuat integrasi acara Amazon S3 di konsol Amazon Redshift**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon Redshift di. [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)
1. Di panel navigasi kiri, pilih integrasi **acara S3**.
1. Pilih **Buat integrasi acara Amazon S3 untuk membuka wizard untuk membuat dan integrasi** acara S3 untuk digunakan dengan auto-copy. Bucket Amazon S3 sumber Anda dan gudang data Amazon Redshift target harus sama. Wilayah AWS Tentukan informasi berikut saat melalui langkah-langkah untuk membuat integrasi:
+ **Nama integrasi** - Adalah pengidentifikasi unik di semua integrasi yang dimiliki oleh Anda Akun AWS saat ini. Wilayah AWS
+ **Deskripsi** - Adalah teks yang menjelaskan integrasi acara Amazon S3 untuk referensi nanti.
+ **Bucket S3 Sumber** — Apakah bucket Amazon S3 Akun AWS saat ini Wilayah AWS dan yang merupakan sumber penyerapan data ke Amazon Redshift.
+ **Gudang data Amazon Redshift** — Apakah klaster yang disediakan Amazon Redshift target atau grup kerja Tanpa Server Redshift yang menerima data dari integrasi.
Jika target Amazon Redshift Anda ada di akun yang sama, Anda dapat memilih target. Jika target ada di akun yang berbeda, Anda menentukan **ARN gudang data Amazon Redshift**. Target harus memiliki kebijakan sumber daya dengan prinsip resmi dan sumber integrasi. Jika Anda tidak memiliki kebijakan sumber daya yang benar pada target dan target Anda berada di akun yang sama, Anda dapat memilih opsi **Perbaiki untuk saya** untuk menerapkan kebijakan sumber daya secara otomatis selama proses integrasi buat. Jika target Anda berbeda Akun AWS, Anda perlu menerapkan kebijakan sumber daya di gudang Amazon Redshift secara manual.
1. Masukkan hingga 50 tag **Kunci** dan dengan **Nilai** opsional — Untuk memberikan metadata tambahan tentang integrasi.
1. Halaman ulasan ditampilkan di mana Anda dapat memilih **Buat integrasi acara S3**.
------
#### [ AWS CLI ]
Untuk membuat integrasi acara Amazon S3 menggunakan AWS CLI, gunakan `create-integration` perintah dengan opsi berikut:
+ `integration-name` – Tentukan nama untuk integrasi.
+ `source-arn`— Tentukan ARN dari bucket sumber Amazon S3.
+ `target-arn`— Tentukan ARN namespace dari cluster yang disediakan Amazon Redshift atau target grup kerja Redshift Serverless.
Contoh berikut menciptakan integrasi dengan memberikan nama integrasi, sumber ARN, dan ARN target. Integrasi tidak dienkripsi.
```
aws redshift create-integration \
--integration-name s3-integration \
--source-arn arn:aws:s3:us-east-1::s3-example-bucket \
--target-arn arn:aws:redshift:us-east-1:123456789012:namespace:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222
{
"IntegrationArn": "arn:aws:redshift:us-east-1:123456789012:integration:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"IntegrationName": "s3-integration",
"SourceArn": "arn:aws:s3:::s3-example-bucket",
"SourceType": "s3-event-notifications",
"TargetArn": "arn:aws:redshift:us-east-1:123456789012:namespace:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Status": "creating",
"Errors": [],
"CreateTime": "2024-10-09T19:08:52.758000+00:00",
"Tags": []
}
```
Anda juga dapat menggunakan AWS CLI perintah berikut untuk mengelola integrasi acara S3 Anda.
+ `delete-integration`— Tentukan ARN integrasi untuk menghapus integrasi acara S3.
+ `modify-integration`— Tentukan ARN integrasi untuk mengubah nama atau deskripsi (atau keduanya) dari integrasi acara S3.
+ `describe-integrations`— Tentukan ARN integrasi untuk melihat properti integrasi acara S3.
Lihat [https://docs.aws.amazon.com/cli/latest/reference/redshift/](https://docs.aws.amazon.com/cli/latest/reference/redshift/) untuk informasi selengkapnya tentang perintah ini.
------
Amazon Redshift kemudian membuat integrasi peristiwa S3 dengan sumber dan target terkait, status, dan informasi tentang status pekerjaan penyalinan otomatis terkait. Anda dapat melihat informasi tentang integrasi acara S3 di konsol Amazon Redshift dengan **memilih integrasi acara S3, dan memilih** integrasi untuk menampilkan detailnya. Integrasi dipisahkan oleh yang dibuat **Di akun saya** dan **Dari akun lain**. **Dalam daftar akun saya** menunjukkan integrasi di mana sumber dan target berada di akun yang sama. Daftar **Dari akun lain** menunjukkan integrasi di mana sumber dimiliki oleh akun lain.
Jika Anda menghapus integrasi acara S3, status COPY JOB yang sesuai berubah dari `1` (aktif) menjadi `0` (tidak aktif/tertunda). Namun, COPY JOB yang sesuai tidak secara otomatis dijatuhkan. Jika nanti Anda mencoba membuat COPY JOB dengan nama yang sama, mungkin ada konflik.
## Membuat dan memantau COPY JOB
Setelah integrasi dibuat, pada halaman **detail integrasi acara S3 untuk integrasi** yang Anda buat, pilih **Buat pekerjaan penyalinan otomatis** untuk membuka editor kueri Amazon Redshift v2 di mana Anda dapat membuat pekerjaan salin otomatis untuk integrasi. Amazon Redshift mencocokkan bucket dalam klausa FROM dalam pernyataan COPY JOB CREATE dengan bucket yang digunakan dalam integrasi acara S3. *Untuk informasi tentang cara menggunakan editor kueri Amazon Redshift v2, lihat [Menanyakan database menggunakan editor kueri Amazon Redshift v2 di](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) Panduan Manajemen Pergeseran Merah Amazon.* Misalnya, jalankan perintah COPY berikut di editor kueri v2 untuk membuat COPY JOB otomatis yang cocok dengan bucket Amazon S3 dengan `s3://amzn-s3-demo-bucket/staging-folder` integrasi peristiwa Amazon S3.
```
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
JOB CREATE my_copy_job_name
AUTO ON;
```
Anda mendefinisikan COPY JOB satu kali. Parameter yang sama digunakan untuk run future.
Untuk menentukan dan mengelola COPY JOB, Anda harus memiliki izin. Untuk informasi tentang pemberian dan pencabutan izin pada COPY JOB, lihat dan. [HIBAH](r_GRANT.md) [MENCABUT](r_REVOKE.md) Untuk informasi selengkapnya tentang pemberian dan pencabutan izin cakupan untuk COPY JOB, lihat dan. [Memberikan izin terbatas](r_GRANT.md#grant-scoped-syntax) [Membatalkan izin tercakup](r_REVOKE.md#revoke-scoped-permissions)
Anda mengelola operasi pemuatan menggunakan opsi untuk CREATE, LIST, SHOW, DROP, ALTER, dan RUN jobs. Untuk informasi selengkapnya, lihat [SALIN PEKERJAAN](r_COPY-JOB.md).
Anda dapat menanyakan tampilan sistem untuk melihat status dan kemajuan COPY JOB. Tampilan disediakan sebagai berikut:
+ [SYS\$1COPY\$1JOB](SYS_COPY_JOB.md)— berisi baris untuk setiap COPY JOB yang saat ini ditentukan.
+ [SYS\$1COPY\$1JOB\$1DETAIL](SYS_COPY_JOB_DETAIL.md)— berisi detail tentang file yang tertunda, kesalahan, dan tertelan untuk setiap COPY JOB.
+ [SYS\$1COPY\$1JOB\$1INFO](SYS_COPY_JOB_INFO.md)— berisi pesan yang dicatat tentang COPY JOB.
+ [SYS\$1LOAD\$1HISTORY](SYS_LOAD_HISTORY.md)— berisi rincian perintah COPY.
+ [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md)— berisi rincian kesalahan perintah COPY.
+ [SVV\$1COPY\$1JOB\$1INTEGRATIONS](SVV_COPY_JOB_INTEGRATIONS.md)— berisi rincian integrasi acara S3.
+ [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md)— berisi kesalahan dari perintah COPY.
+ [STL\$1LOAD\$1COMMIT](r_STL_LOAD_COMMITS.md)— berisi informasi yang digunakan untuk memecahkan masalah beban data perintah COPY.
Untuk informasi tentang pemecahan masalah kesalahan integrasi peristiwa S3, lihat. [Memecahkan masalah integrasi acara S3 dan kesalahan COPY JOB](s3-integration-troubleshooting.md)
Untuk mendapatkan daftar file yang dimuat oleh COPY JOB, jalankan SQL berikut, tetapi ganti ** terlebih dahulu:
```
SELECT job_id, job_name, data_source, copy_query, filename, status, curtime
FROM sys_copy_job copyjob
JOIN stl_load_commits loadcommit
ON copyjob.job_id = loadcommit.copy_job_id
WHERE job_id = ;
```
## Pertimbangan saat membuat integrasi acara S3 untuk salinan otomatis
Pertimbangkan hal berikut saat menggunakan auto-copy.
+ Anda dapat membuat maksimal 200 COPY JOBS untuk setiap cluster atau workgroup dalam file Akun AWS.
+ Anda dapat membuat maksimal 50 integrasi acara S3 untuk setiap target Amazon Redshift.
+ Anda tidak dapat membuat integrasi acara S3 dengan bucket Amazon S3 sumber yang memiliki titik (.) dalam nama bucket.
+ Anda hanya dapat membuat satu integrasi acara S3 antara sumber dan target yang sama. Artinya, hanya ada satu integrasi acara S3 antara bucket Amazon S3 dan gudang data Amazon Redshift sekaligus.
+ Anda tidak dapat memiliki pemberitahuan peristiwa yang ada untuk jenis acara `S3_OBJECT_CREATED` yang ditentukan pada bucket Amazon S3 sumber. Namun, setelah integrasi acara S3 dibuat, Anda dapat memperbarui notifikasi acara bucket Amazon S3 dengan cakupan prefix/suffix yang lebih sempit. Dengan cara ini, Anda juga dapat mengonfigurasi `S3_OBJECT_CREATED` target lain prefix/suffix ke target lain dan menghindari konflik dengan integrasi acara S3. Jika Anda mengalami masalah bahwa penyalinan otomatis tidak berjalan seperti yang diharapkan, siapkan AWS CloudTrail log `s3:PutBucketNotificationConfiguration` tindakan pada bucket S3 Anda untuk kerangka waktu yang dimaksud saat Anda menghubungi. AWS Dukungan
## Wilayah yang Didukung
Wilayah berikut tersedia untuk salinan otomatis.
| Region | Salin otomatis |
| --- | --- |
| Africa (Cape Town) | Available |
| Asia Pasifik (Hong Kong) | Available |
| Asia Pasifik (Taipei) | Available |
| Asia Pasifik (Tokyo) | Available |
| Asia Pasifik (Seoul) | Available |
| Asia Pasifik (Osaka) | Available |
| Asia Pasifik (Mumbai) | Available |
| Asia Pasifik (Hyderabad) | Available |
| Asia Pasifik (Singapura) | Available |
| Asia Pasifik (Sydney) | Available |
| Asia Pasifik (Jakarta) | Available |
| Asia Pacific (Melbourne) | Available |
| Asia Pasifik (Malaysia) | Available |
| Asia Pasifik (Selandia Baru) | Tidak tersedia |
| Asia Pasifik (Thailand) | Available |
| Kanada (Pusat) | Available |
| Kanada Barat (Calgary) | Available |
| Tiongkok (Beijing) | Available |
| Tiongkok (Ningxia) | Available |
| Eropa (Frankfurt) | Available |
| Europe (Zurich) | Available |
| Eropa (Stockholm) | Available |
| Europe (Milan) | Available |
| Eropa (Spanyol) | Available |
| Eropa (Irlandia) | Available |
| Eropa (London) | Available |
| Eropa (Paris) | Available |
| Israel (Tel Aviv) | Available |
| Timur Tengah (UAE) | Available |
| Timur Tengah (Bahrain) | Available |
| Meksiko (Tengah) | Available |
| Amerika Selatan (Sao Paulo) | Available |
| AS Timur (Virginia Utara) | Available |
| AS Timur (Ohio) | Available |
| AS Barat (California Utara) | Available |
| AS Barat (Oregon) | Available |
| AWS GovCloud (AS-Timur) | Available |
| AWS GovCloud (AS-Barat) | Available |
# Memuat tabel dengan perintah DML
Amazon Redshift mendukung perintah bahasa manipulasi data standar (DHTML) (INSERT, UPDATE, dan DELETE) yang dapat Anda gunakan untuk memodifikasi baris dalam tabel. Anda juga dapat menggunakan perintah TRUNCATE untuk melakukan penghapusan massal cepat.
**catatan**
Kami sangat menyarankan Anda untuk menggunakan [MENYONTEK](r_COPY.md) perintah untuk memuat sejumlah besar data. Menggunakan pernyataan INSERT individu untuk mengisi tabel mungkin sangat lambat. Atau, jika data Anda sudah ada di tabel database Amazon Redshift lainnya, gunakan INSERT INTO... PILIH DARI atau BUAT TABEL AS untuk meningkatkan kinerja. Untuk informasi, lihat [INSERT](r_INSERT_30.md) atau[CREATE TABLE AS](r_CREATE_TABLE_AS.md).
Jika Anda menyisipkan, memperbarui, atau menghapus sejumlah besar baris dalam tabel, relatif terhadap jumlah baris sebelum perubahan, jalankan perintah ANALYZE dan VACUUM terhadap tabel ketika Anda selesai. Jika sejumlah perubahan kecil terakumulasi dari waktu ke waktu dalam aplikasi Anda, Anda mungkin ingin menjadwalkan perintah ANALYSIS dan VACUUM untuk berjalan secara berkala. Untuk informasi selengkapnya, lihat [Menganalisis tabel](t_Analyzing_tables.md) dan [Tabel penyedot debu](t_Reclaiming_storage_space202.md).
**Topics**
+ [Memperbarui dan menyisipkan data baru](t_updating-inserting-using-staging-tables-.md)
# Memperbarui dan menyisipkan data baru
Anda dapat secara efisien menambahkan data baru ke tabel yang ada dengan menggunakan perintah MERGE. Lakukan operasi gabungan dengan membuat tabel pementasan dan kemudian menggunakan salah satu metode yang dijelaskan di bagian ini untuk memperbarui tabel target dari tabel pementasan. Untuk informasi selengkapnya tentang perintah MERGE, lihat[MERGE](r_MERGE.md).
[Gabungkan contoh](merge-examples.md)Penggunaan kumpulan data sampel untuk Amazon Redshift, yang disebut kumpulan data TICKIT. Sebagai prasyarat, Anda dapat mengatur tabel dan data TICKIT dengan mengikuti petunjuk yang tersedia di [Memulai](https://docs.aws.amazon.com/redshift/latest/gsg/database-tasks.html) tugas database umum. Informasi lebih rinci tentang kumpulan data sampel ditemukan di [database Sampel](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).
## Gabungkan metode 1: Mengganti baris yang ada
Jika Anda menimpa semua kolom dalam tabel target, metode tercepat untuk melakukan penggabungan adalah dengan mengganti baris yang ada. Ini memindai tabel target hanya sekali, dengan menggunakan gabungan dalam untuk menghapus baris yang akan diperbarui. Setelah baris dihapus, mereka diganti dengan baris baru dengan operasi sisipan tunggal dari tabel pementasan.
Gunakan metode ini jika semua hal berikut benar:
+ Tabel target Anda dan tabel pementasan Anda berisi kolom yang sama.
+ Anda bermaksud mengganti semua data di kolom tabel target dengan semua kolom tabel pementasan.
+ Anda akan menggunakan semua baris dalam tabel pementasan dalam penggabungan.
Jika salah satu kriteria ini tidak berlaku, gunakan metode Gabung 2: Menentukan daftar kolom tanpa menggunakan MERGE, dijelaskan di bagian berikut.
Jika Anda tidak akan menggunakan semua baris dalam tabel pementasan, filter pernyataan DELETE dan INSERT dengan menggunakan klausa WHERE untuk meninggalkan baris yang tidak berubah. Namun, jika sebagian besar baris dalam tabel pementasan tidak akan berpartisipasi dalam penggabungan, kami sarankan melakukan UPDATE dan INSERT dalam langkah-langkah terpisah, seperti yang dijelaskan nanti di bagian ini.
## Menggabungkan metode 2: Menentukan daftar kolom tanpa menggunakan MERGE
Gunakan metode ini untuk memperbarui kolom tertentu dalam tabel target alih-alih menimpa seluruh baris. Metode ini memakan waktu lebih lama dari metode sebelumnya karena memerlukan langkah pembaruan tambahan dan tidak menggunakan perintah MERGE. Gunakan metode ini jika salah satu dari berikut ini benar:
+ Tidak semua kolom dalam tabel target akan diperbarui.
+ Sebagian besar baris dalam tabel pementasan tidak akan digunakan dalam pembaruan.
**Topics**
+ [Gabungkan metode 1: Mengganti baris yang ada](#merge-method-replace-existing-rows)
+ [Menggabungkan metode 2: Menentukan daftar kolom tanpa menggunakan MERGE](#merge-method-specify-column-list)
+ [Membuat tabel pementasan sementara](merge-create-staging-table.md)
+ [Melakukan operasi penggabungan dengan mengganti baris yang ada](merge-replacing-existing-rows.md)
+ [Melakukan operasi gabungan dengan menentukan daftar kolom tanpa menggunakan perintah MERGE](merge-specify-a-column-list.md)
+ [Gabungkan contoh](merge-examples.md)
# Membuat tabel pementasan sementara
*Tabel pementasan* adalah tabel sementara yang menyimpan semua data yang akan digunakan untuk membuat perubahan pada *tabel target*, termasuk pembaruan dan sisipan.
Operasi penggabungan membutuhkan gabungan antara tabel pementasan dan tabel target. Untuk mengurutkan baris yang bergabung, atur kunci distribusi tabel pementasan ke kolom yang sama dengan kunci distribusi tabel target. Misalnya, jika tabel target menggunakan kolom kunci asing sebagai kunci distribusinya, gunakan kolom yang sama untuk kunci distribusi tabel pementasan. Jika Anda membuat tabel pementasan dengan menggunakan [CREATE TABLE LIKE](r_CREATE_TABLE_NEW.md#create-table-like) pernyataan, tabel pementasan akan mewarisi kunci distribusi dari tabel induk. Jika Anda menggunakan pernyataan CREATE TABLE AS, tabel baru tidak mewarisi kunci distribusi. Untuk informasi selengkapnya, lihat [Distribusi data untuk optimasi kueri](t_Distributing_data.md)
Jika kunci distribusi tidak sama dengan kunci utama dan kunci distribusi tidak diperbarui sebagai bagian dari operasi penggabungan, tambahkan predikat gabungan redundan pada kolom kunci distribusi untuk mengaktifkan gabungan yang ditempatkan. Contoh:
```
where target.primarykey = stage.primarykey
and target.distkey = stage.distkey
```
Untuk memverifikasi bahwa kueri akan menggunakan gabungan yang ditempatkan, jalankan kueri dengan [EXPLAIN](r_EXPLAIN.md) dan periksa DS\$1DIST\$1NONE pada semua gabungan. Untuk informasi selengkapnya, lihat [Mengevaluasi rencana kueri](c_data_redistribution.md)
# Melakukan operasi penggabungan dengan mengganti baris yang ada
Saat Anda menjalankan operasi penggabungan yang dirinci dalam prosedur, letakkan semua langkah kecuali untuk membuat dan menjatuhkan tabel pementasan sementara dalam satu transaksi. Transaksi bergulir kembali jika ada langkah yang gagal. Menggunakan satu transaksi juga mengurangi jumlah komit, yang menghemat waktu dan sumber daya.
**Untuk melakukan operasi penggabungan dengan mengganti baris yang ada**
1. Buat tabel pementasan, lalu isi dengan data yang akan digabungkan, seperti yang ditunjukkan pada pseudocode berikut.
```
CREATE temp table stage (like target);
INSERT INTO stage
SELECT * FROM source
WHERE source.filter = 'filter_expression';
```
1. Gunakan MERGE untuk melakukan penggabungan batin dengan tabel pementasan untuk memperbarui baris dari tabel target yang cocok dengan tabel pementasan, lalu masukkan semua baris yang tersisa ke dalam tabel target yang tidak cocok dengan tabel pementasan.
Kami menyarankan Anda menjalankan pembaruan dan menyisipkan operasi dalam satu perintah MERGE.
```
MERGE INTO target
USING stage [optional alias] on (target.primary_key = stage.primary_key)
WHEN MATCHED THEN
UPDATE SET col_name1 = stage.col_name1 , col_name2= stage.col_name2, col_name3 = {expr}
WHEN NOT MATCHED THEN
INSERT (col_name1 , col_name2, col_name3) VALUES (stage.col_name1, stage.col_name2, {expr});
```
1. Jatuhkan meja pementasan.
```
DROP TABLE stage;
```
# Melakukan operasi gabungan dengan menentukan daftar kolom tanpa menggunakan perintah MERGE
Saat Anda menjalankan operasi penggabungan yang dirinci dalam prosedur, masukkan semua langkah dalam satu transaksi. Transaksi bergulir kembali jika ada langkah yang gagal. Menggunakan satu transaksi juga mengurangi jumlah komit, yang menghemat waktu dan sumber daya.
**Untuk melakukan operasi gabungan dengan menentukan daftar kolom**
1. Letakkan seluruh operasi dalam satu blok transaksi.
```
BEGIN transaction;
…
END transaction;
```
1. Buat tabel pementasan, lalu isi dengan data yang akan digabungkan, seperti yang ditunjukkan pada pseudocode berikut.
```
create temp table stage (like target);
insert into stage
select * from source
where source.filter = 'filter_expression';
```
1. Perbarui tabel target dengan menggunakan gabungan bagian dalam dengan tabel pementasan.
+ Dalam klausa UPDATE, secara eksplisit daftar kolom yang akan diperbarui.
+ Lakukan gabungan batin dengan tabel pementasan.
+ Jika kunci distribusi berbeda dari kunci utama dan kunci distribusi tidak diperbarui, tambahkan gabungan redundan pada kunci distribusi. Untuk memverifikasi bahwa kueri akan menggunakan gabungan yang ditempatkan, jalankan kueri dengan [EXPLAIN](r_EXPLAIN.md) dan periksa DS\$1DIST\$1NONE pada semua gabungan. Untuk informasi selengkapnya, lihat [Mengevaluasi rencana kueri](c_data_redistribution.md)
+ Jika tabel target Anda diurutkan berdasarkan stempel waktu, tambahkan predikat untuk memanfaatkan pemindaian terbatas rentang pada tabel target. Untuk informasi selengkapnya, lihat [Praktik terbaik Amazon Redshift untuk mendesain kueri](c_designing-queries-best-practices.md).
+ Jika Anda tidak akan menggunakan semua baris dalam penggabungan, tambahkan klausa untuk memfilter baris yang ingin Anda ubah. Misalnya, tambahkan filter ketidaksetaraan pada satu atau beberapa kolom untuk mengecualikan baris yang belum berubah.
+ Masukkan pembaruan, hapus, dan sisipkan operasi dalam satu blok transaksi sehingga jika ada masalah, semuanya akan dibatalkan.
Contoh:
```
begin transaction;
update target
set col1 = stage.col1,
col2 = stage.col2,
col3 = 'expression'
from stage
where target.primarykey = stage.primarykey
and target.distkey = stage.distkey
and target.col3 > 'last_update_time'
and (target.col1 != stage.col1
or target.col2 != stage.col2
or target.col3 = 'filter_expression');
```
1. Hapus baris yang tidak dibutuhkan dari tabel pementasan dengan menggunakan gabungan batin dengan tabel target. Beberapa baris di tabel target sudah cocok dengan baris yang sesuai di tabel pementasan, dan lainnya diperbarui pada langkah sebelumnya. Dalam kedua kasus, mereka tidak diperlukan untuk sisipan.
```
delete from stage
using target
where stage.primarykey = target.primarykey;
```
1. Masukkan baris yang tersisa dari tabel pementasan. Gunakan daftar kolom yang sama dalam klausa VALUES yang Anda gunakan dalam pernyataan UPDATE di langkah kedua.
```
insert into target
(select col1, col2, 'expression'
from stage);
end transaction;
```
1. Jatuhkan meja pementasan.
```
drop table stage;
```
# Gabungkan contoh
Contoh berikut melakukan penggabungan untuk memperbarui tabel PENJUALAN. Contoh pertama menggunakan metode sederhana menghapus dari tabel target dan kemudian memasukkan semua baris dari tabel pementasan. Contoh kedua memerlukan pembaruan pada kolom tertentu di tabel target, sehingga termasuk langkah pembaruan tambahan.
[Gabungkan contoh](#merge-examples)Penggunaan kumpulan data sampel untuk Amazon Redshift, yang disebut kumpulan data TICKIT. Sebagai prasyarat, Anda dapat mengatur tabel dan data TICKIT dengan mengikuti petunjuk yang tersedia di panduan [Memulai](https://docs.aws.amazon.com/redshift/latest/gsg/database-tasks.html) tugas basis data umum. Informasi lebih rinci tentang kumpulan data sampel ditemukan di [database Sampel](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).
**Contoh menggabungkan sumber data**
Contoh di bagian ini memerlukan sumber data sampel yang mencakup pembaruan dan sisipan. Sebagai contoh, kita akan membuat tabel sampel bernama SALES\$1UPDATE yang menggunakan data dari tabel SALES. Kami akan mengisi tabel baru dengan data acak yang mewakili aktivitas penjualan baru untuk bulan Desember. Kami akan menggunakan tabel sampel SALES\$1UPDATE untuk membuat tabel pementasan dalam contoh berikut.
```
-- Create a sample table as a copy of the SALES table.
create table tickit.sales_update as
select * from tickit.sales;
-- Change every fifth row to have updates.
update tickit.sales_update
set qtysold = qtysold*2,
pricepaid = pricepaid*0.8,
commission = commission*1.1
where saletime > '2008-11-30'
and mod(sellerid, 5) = 0;
-- Add some new rows to have inserts.
-- This example creates a duplicate of every fourth row.
insert into tickit.sales_update
select (salesid + 172456) as salesid, listid, sellerid, buyerid, eventid, dateid, qtysold, pricepaid, commission, getdate() as saletime
from tickit.sales_update
where saletime > '2008-11-30'
and mod(sellerid, 4) = 0;
```
**Contoh penggabungan yang menggantikan baris yang ada berdasarkan kunci yang cocok**
Skrip berikut menggunakan tabel SALES\$1UPDATE untuk melakukan operasi gabungan pada tabel PENJUALAN dengan data baru untuk aktivitas penjualan Desember. Contoh ini menggantikan baris dalam tabel PENJUALAN yang memiliki pembaruan. Untuk contoh ini, kami akan memperbarui kolom qtysold dan pricepaid, tetapi membiarkan komisi dan waktu penjualan tidak berubah.
```
MERGE into tickit.sales
USING tickit.sales_update sales_update
on ( sales.salesid = sales_update.salesid
and sales.listid = sales_update.listid
and sales_update.saletime > '2008-11-30'
and (sales.qtysold != sales_update.qtysold
or sales.pricepaid != sales_update.pricepaid))
WHEN MATCHED THEN
update SET qtysold = sales_update.qtysold,
pricepaid = sales_update.pricepaid
WHEN NOT MATCHED THEN
INSERT (salesid, listid, sellerid, buyerid, eventid, dateid, qtysold , pricepaid, commission, saletime)
values (sales_update.salesid, sales_update.listid, sales_update.sellerid, sales_update.buyerid, sales_update.eventid,
sales_update.dateid, sales_update.qtysold , sales_update.pricepaid, sales_update.commission, sales_update.saletime);
-- Drop the staging table.
drop table tickit.sales_update;
-- Test to see that commission and salestime were not impacted.
SELECT sales.salesid, sales.commission, sales.salestime, sales_update.commission, sales_update.salestime
FROM tickit.sales
INNER JOIN tickit.sales_update sales_update
ON
sales.salesid = sales_update.salesid
AND sales.listid = sales_update.listid
AND sales_update.saletime > '2008-11-30'
AND (sales.commission != sales_update.commission
OR sales.salestime != sales_update.salestime);
```
**Contoh gabungan yang menentukan daftar kolom tanpa menggunakan MERGE**
Contoh berikut melakukan operasi penggabungan untuk memperbarui PENJUALAN dengan data baru untuk aktivitas penjualan Desember. Kami membutuhkan data sampel yang mencakup pembaruan dan sisipan, bersama dengan baris yang tidak berubah. Untuk contoh ini, kami ingin memperbarui kolom QTYSOLD dan PRICEPAID tetapi membiarkan KOMISI dan SALETIME tidak berubah. Skrip berikut menggunakan tabel SALES\$1UPDATE untuk melakukan operasi gabungan pada tabel PENJUALAN.
```
-- Create a staging table and populate it with rows from SALES_UPDATE for Dec
create temp table stagesales as select * from sales_update
where saletime > '2008-11-30';
-- Start a new transaction
begin transaction;
-- Update the target table using an inner join with the staging table
-- The join includes a redundant predicate to collocate on the distribution key –- A filter on saletime enables a range-restricted scan on SALES
update sales
set qtysold = stagesales.qtysold,
pricepaid = stagesales.pricepaid
from stagesales
where sales.salesid = stagesales.salesid
and sales.listid = stagesales.listid
and stagesales.saletime > '2008-11-30'
and (sales.qtysold != stagesales.qtysold
or sales.pricepaid != stagesales.pricepaid);
-- Delete matching rows from the staging table
-- using an inner join with the target table
delete from stagesales
using sales
where sales.salesid = stagesales.salesid
and sales.listid = stagesales.listid;
-- Insert the remaining rows from the staging table into the target table
insert into sales
select * from stagesales;
-- End transaction and commit
end transaction;
-- Drop the staging table
drop table stagesales;
```
# Melakukan salinan yang dalam
Salinan mendalam membuat ulang dan mengisi ulang tabel dengan menggunakan sisipan massal, yang secara otomatis mengurutkan tabel. Jika sebuah tabel memiliki Wilayah besar yang tidak disortir, salinan dalam jauh lebih cepat daripada ruang hampa. Kami menyarankan Anda hanya membuat pembaruan bersamaan selama operasi penyalinan mendalam jika Anda dapat melacaknya. Setelah proses selesai, pindahkan pembaruan delta ke tabel baru. Operasi VACUUM mendukung pembaruan bersamaan secara otomatis.
Anda dapat memilih salah satu metode berikut untuk membuat salinan tabel asli:
+ Gunakan tabel asli DDL.
Jika CREATE TABLE DDL tersedia, ini adalah metode tercepat dan disukai. Jika Anda membuat tabel baru, Anda dapat menentukan semua atribut tabel dan kolom, termasuk kunci primer dan kunci asing. Anda dapat menemukan DDL asli dengan menggunakan fungsi SHOW TABLE.
+ Gunakan CREATE TABLE LIKE.
Jika DDL asli tidak tersedia, Anda dapat menggunakan CREATE TABLE LIKE untuk membuat ulang tabel asli. Tabel baru mewarisi encoding, kunci distribusi, kunci sortir, dan atribut bukan-null dari tabel induk. Tabel baru tidak mewarisi kunci primer dan atribut kunci asing dari tabel induk, tetapi Anda dapat menambahkannya menggunakan[ALTER TABLE](r_ALTER_TABLE.md).
+ Buat tabel sementara dan potong tabel asli.
Jika Anda harus mempertahankan kunci primer dan atribut kunci asing dari tabel induk. Jika tabel induk memiliki dependensi, Anda dapat menggunakan CREATE TABLE... AS (CTAS) untuk membuat tabel sementara. Kemudian potong tabel asli dan isi dari tabel sementara.
Menggunakan tabel sementara meningkatkan kinerja secara signifikan dibandingkan dengan menggunakan tabel permanen, tetapi ada risiko kehilangan data. Tabel sementara secara otomatis dijatuhkan di akhir sesi di mana ia dibuat. TRUNCATE berkomitmen segera, bahkan jika itu berada di dalam blok transaksi. Jika TRUNCATE berhasil tetapi sesi dimatikan sebelum INSERT berikut selesai, data akan hilang. Jika kehilangan data tidak dapat diterima, gunakan tabel permanen.
Setelah membuat salinan tabel, Anda mungkin harus memberikan akses ke tabel baru. Anda dapat menggunakan [HIBAH](r_GRANT.md) untuk menentukan hak akses. Untuk melihat dan memberikan semua hak akses tabel, Anda harus menjadi salah satu dari yang berikut:
+ Seorang pengguna super.
+ Pemilik tabel yang ingin Anda salin.
+ Pengguna dengan hak istimewa ACCESS SYSTEM TABLE untuk melihat hak istimewa tabel, dan dengan hak istimewa pemberian untuk semua izin yang relevan.
Selain itu, Anda mungkin harus memberikan izin penggunaan untuk skema salinan mendalam Anda. Pemberian izin penggunaan diperlukan jika skema deep copy Anda berbeda dari skema tabel asli, dan juga bukan skema. `public` Untuk melihat dan memberikan hak penggunaan, Anda harus menjadi salah satu dari yang berikut:
+ Seorang pengguna super.
+ Pengguna yang dapat memberikan izin USE untuk skema deep copy.
**Untuk melakukan deep copy menggunakan tabel asli DDL**
1. (Opsional) Buat ulang tabel DDL dengan menjalankan skrip yang disebut. `v_generate_tbl_ddl`
1. Buat salinan tabel menggunakan CREATE TABLE DDL asli.
1. Gunakan pernyataan INSERT INTO... SELECT untuk mengisi salinan dengan data dari tabel asli.
1. Periksa izin yang diberikan pada tabel lama. Anda dapat melihat izin ini di tampilan sistem SVV\$1RELATION\$1PRIVILEGES.
1. Jika perlu, berikan izin tabel lama ke tabel baru.
1. Berikan izin penggunaan kepada setiap grup dan pengguna yang memiliki hak istimewa di tabel asli. Langkah ini tidak diperlukan jika tabel deep copy Anda ada dalam `public` skema, atau berada dalam skema yang sama dengan tabel asli.
1. Jatuhkan meja aslinya.
1. Gunakan pernyataan ALTER TABLE untuk mengganti nama salinan ke nama tabel asli.
Contoh berikut melakukan deep copy pada tabel SAMPLE menggunakan duplikat SAMPLE bernama sample\$1copy.
```
--Create a copy of the original table in the sample_namespace namespace using the original CREATE TABLE DDL.
create table sample_namespace.sample_copy ( … );
--Populate the copy with data from the original table in the public namespace.
insert into sample_namespace.sample_copy (select * from public.sample);
--Check SVV_RELATION_PRIVILEGES for the original table's privileges.
select * from svv_relation_privileges where namespace_name = 'public' and relation_name = 'sample' order by identity_type, identity_id, privilege_type;
--Grant the original table's privileges to the copy table.
grant DELETE on table sample_namespace.sample_copy to group group1;
grant INSERT, UPDATE on table sample_namespace.sample_copy to group group2;
grant SELECT on table sample_namespace.sample_copy to user1;
grant INSERT, SELECT, UPDATE on table sample_namespace.sample_copy to user2;
--Grant usage permission to every group and user that has privileges in the original table.
grant USAGE on schema sample_namespace to group group1, group group2, user1, user2;
--Drop the original table.
drop table public.sample;
--Rename the copy table to match the original table's name.
alter table sample_namespace.sample_copy rename to sample;
```
**Untuk melakukan deep copy menggunakan CREATE TABLE LIKE**
1. Buat tabel baru menggunakan CREATE TABLE LIKE.
1. Gunakan pernyataan INSERT INTO... SELECT untuk menyalin baris dari tabel saat ini ke tabel baru.
1. Periksa izin yang diberikan pada tabel lama. Anda dapat melihat izin ini di tampilan sistem SVV\$1RELATION\$1PRIVILEGES.
1. Jika perlu, berikan izin tabel lama ke tabel baru.
1. Berikan izin penggunaan kepada setiap grup dan pengguna yang memiliki hak istimewa di tabel asli. Langkah ini tidak diperlukan jika tabel deep copy Anda ada dalam `public` skema, atau berada dalam skema yang sama dengan tabel asli.
1. Jatuhkan tabel saat ini.
1. Gunakan pernyataan ALTER TABLE untuk mengganti nama tabel baru menjadi nama tabel asli.
Contoh berikut melakukan deep copy pada tabel SAMPLE menggunakan CREATE TABLE LIKE.
```
--Create a copy of the original table in the sample_namespace namespace using CREATE TABLE LIKE.
create table sameple_namespace.sample_copy (like public.sample);
--Populate the copy with data from the original table.
insert into sample_namespace.sample_copy (select * from public.sample);
--Check SVV_RELATION_PRIVILEGES for the original table's privileges.
select * from svv_relation_privileges where namespace_name = 'public' and relation_name = 'sample' order by identity_type, identity_id, privilege_type;
--Grant the original table's privileges to the copy table.
grant DELETE on table sample_namespace.sample_copy to group group1;
grant INSERT, UPDATE on table sample_namespace.sample_copy to group group2;
grant SELECT on table sample_namespace.sample_copy to user1;
grant INSERT, SELECT, UPDATE on table sample_namespace.sample_copy to user2;
--Grant usage permission to every group and user that has privileges in the original table.
grant USAGE on schema sample_namespace to group group1, group group2, user1, user2;
--Drop the original table.
drop table public.sample;
--Rename the copy table to match the original table's name.
alter table sample_namespace.sample_copy rename to sample;
```
**Untuk melakukan penyalinan mendalam dengan membuat tabel sementara dan memotong tabel asli**
1. Gunakan CREATE TABLE AS untuk membuat tabel sementara dengan baris dari tabel asli.
1. Memotong tabel saat ini.
1. Gunakan pernyataan INSERT INTO... SELECT untuk menyalin baris dari tabel sementara ke tabel asli.
1. Jatuhkan meja sementara.
Contoh berikut melakukan salinan mendalam pada tabel PENJUALAN dengan membuat tabel sementara dan memotong tabel asli. Karena tabel asli tetap ada, Anda tidak perlu memberikan izin ke tabel salin.
```
--Create a temp table copy using CREATE TABLE AS.
create temp table salestemp as select * from sales;
--Truncate the original table.
truncate sales;
--Copy the rows from the temporary table to the original table.
insert into sales (select * from salestemp);
--Drop the temporary table.
drop table salestemp;
```
# Menganalisis tabel
Operasi ANALISIS memperbarui metadata statistik yang digunakan perencana kueri untuk memilih paket yang optimal.
Dalam kebanyakan kasus, Anda tidak perlu menjalankan perintah ANALYZE secara eksplisit. Amazon Redshift memantau perubahan pada beban kerja Anda dan secara otomatis memperbarui statistik di latar belakang. Selain itu, perintah COPY melakukan analisis secara otomatis ketika memuat data ke dalam tabel kosong.
Untuk secara eksplisit menganalisis tabel atau seluruh database, jalankan perintah. [MENGANALISA](r_ANALYZE.md)
## Analisis otomatis
Amazon Redshift terus memantau database Anda dan secara otomatis melakukan operasi analisis di latar belakang. Untuk meminimalkan dampak terhadap kinerja sistem Anda, analisis otomatis berjalan selama periode ketika beban kerja ringan.
Analisis otomatis diaktifkan secara default. Untuk mematikan analisis otomatis, atur `auto_analyze` parameter **false** dengan memodifikasi grup parameter cluster Anda.
Untuk mengurangi waktu pemrosesan dan meningkatkan kinerja sistem secara keseluruhan, Amazon Redshift melewatkan analisis otomatis untuk tabel mana pun yang tingkat modifikasinya kecil.
Operasi analisis melewatkan tabel yang memiliki up-to-date statistik. Jika Anda menjalankan ANALYZE sebagai bagian dari alur kerja ekstrak, transformasi, dan muat (ETL), analisis otomatis melewatkan tabel yang memiliki statistik saat ini. Demikian pula, ANALISIS eksplisit melewatkan tabel ketika analisis otomatis telah memperbarui statistik tabel.
## Analisis data tabel baru
Secara default, perintah COPY melakukan ANALISIS setelah memuat data ke dalam tabel kosong. Anda dapat memaksa ANALYSIS terlepas dari apakah tabel kosong dengan menyetel STATUPDATE ON. Jika Anda menentukan STATUPDATE OFF, ANALISIS tidak dilakukan. Hanya pemilik tabel atau superuser yang dapat menjalankan perintah ANALYZE atau menjalankan perintah COPY dengan STATUPDATE disetel ke ON.
Amazon Redshift juga menganalisis tabel baru yang Anda buat dengan perintah berikut:
+ BUAT TABEL SEBAGAI (CTAS)
+ BUAT TABEL TEMP SEBAGAI
+ PILIH KE
Amazon Redshift mengembalikan pesan peringatan saat Anda menjalankan kueri terhadap tabel baru yang tidak dianalisis setelah datanya awalnya dimuat. Tidak ada peringatan yang terjadi saat Anda menanyakan tabel setelah pembaruan atau pemuatan berikutnya. Pesan peringatan yang sama ditampilkan saat Anda menjalankan perintah EXPLOW pada kueri yang mereferensikan tabel yang belum dianalisis.
Setiap kali menambahkan data ke tabel nonempty secara signifikan mengubah ukuran tabel, Anda dapat secara eksplisit memperbarui statistik. Anda melakukannya baik dengan menjalankan perintah ANALYZE atau dengan menggunakan opsi STATUPDATE ON dengan perintah COPY. Untuk melihat detail tentang jumlah baris yang telah disisipkan atau dihapus sejak ANALISIS terakhir, kueri tabel katalog [PG\$1STATISTIC\$1INDICATOR](r_PG_STATISTIC_INDICATOR.md) sistem.
Anda dapat menentukan ruang lingkup [MENGANALISA](r_ANALYZE.md) perintah ke salah satu dari berikut ini:
+ Seluruh database saat ini
+ Satu meja
+ Satu atau lebih kolom spesifik dalam satu tabel
+ Kolom yang kemungkinan akan digunakan sebagai predikat dalam kueri
Perintah ANALYZE mendapatkan contoh baris dari tabel, melakukan beberapa perhitungan, dan menyimpan statistik kolom yang dihasilkan. Secara default, Amazon Redshift menjalankan sample pass untuk kolom DISTKEY dan pass sampel lainnya untuk semua kolom lain dalam tabel. Jika Anda ingin menghasilkan statistik untuk subset kolom, Anda dapat menentukan daftar kolom yang dipisahkan koma. Anda dapat menjalankan ANALYZE dengan klausa PREDICATE COLUMNS untuk melewati kolom yang tidak digunakan sebagai predikat.
Operasi ANALISIS bersifat intensif sumber daya, jadi jalankan hanya pada tabel dan kolom yang benar-benar memerlukan pembaruan statistik. Anda tidak perlu menganalisis semua kolom di semua tabel secara teratur atau pada jadwal yang sama. Jika data berubah secara substansif, analisis kolom yang sering digunakan sebagai berikut:
+ Operasi penyortiran dan pengelompokan
+ Gabungan
+ Predikat kueri
Untuk mengurangi waktu pemrosesan dan meningkatkan kinerja sistem secara keseluruhan, Amazon Redshift melewatkan ANALISIS untuk tabel apa pun yang memiliki persentase baris yang diubah rendah, sebagaimana ditentukan oleh parameter. [analyze\$1threshold\$1percent](r_analyze_threshold_percent.md) Secara default, ambang analisis diatur ke 10 persen. Anda dapat mengubah ambang analisis untuk sesi saat ini dengan menjalankan [SET](r_SET.md) perintah.
Kolom yang cenderung tidak memerlukan analisis yang sering adalah kolom yang mewakili fakta dan ukuran dan atribut terkait apa pun yang tidak pernah benar-benar ditanyakan, seperti kolom VARCHAR besar. Misalnya, pertimbangkan tabel LISTING dalam database TICKIT.
```
select "column", type, encoding, distkey, sortkey
from pg_table_def where tablename = 'listing';
column | type | encoding | distkey | sortkey
---------------+--------------------+----------+---------+---------
listid | integer | none | t | 1
sellerid | integer | none | f | 0
eventid | integer | mostly16 | f | 0
dateid | smallint | none | f | 0
numtickets | smallint | mostly8 | f | 0
priceperticket | numeric(8,2) | bytedict | f | 0
totalprice | numeric(8,2) | mostly32 | f | 0
listtime | timestamp with... | none | f | 0
```
Jika tabel ini dimuat setiap hari dengan sejumlah besar catatan baru, kolom LISTID, yang sering digunakan dalam kueri sebagai kunci gabungan, harus dianalisis secara teratur. Jika TOTALPRICE dan LISTTIME adalah kendala yang sering digunakan dalam kueri, Anda dapat menganalisis kolom tersebut dan kunci distribusi setiap hari kerja.
```
analyze listing(listid, totalprice, listtime);
```
Misalkan penjual dan acara dalam aplikasi jauh lebih statis, dan tanggalnya IDs mengacu pada serangkaian hari tetap yang hanya mencakup dua atau tiga tahun. Dalam hal ini, nilai unik untuk kolom ini tidak berubah secara signifikan. Namun, jumlah contoh dari setiap nilai unik akan terus meningkat.
Selain itu, pertimbangkan kasus di mana tindakan NUMTICKETS dan PRICEPERTICKET jarang ditanyakan dibandingkan dengan kolom TOTALPRICE. Dalam hal ini, Anda dapat menjalankan perintah ANALISIS di seluruh tabel sekali setiap akhir pekan untuk memperbarui statistik untuk lima kolom yang tidak dianalisis setiap hari:
**Kolom predikat**
Sebagai alternatif yang nyaman untuk menentukan daftar kolom, Anda dapat memilih untuk menganalisis hanya kolom yang kemungkinan akan digunakan sebagai predikat. Saat Anda menjalankan kueri, kolom apa pun yang digunakan dalam gabungan, kondisi filter, atau grup berdasarkan klausa ditandai sebagai kolom predikat dalam katalog sistem. Saat Anda menjalankan ANALISIS dengan klausa KOLOM PREDIKAT, operasi analisis hanya mencakup kolom yang memenuhi kriteria berikut:
+ Kolom ditandai sebagai kolom predikat.
+ Kolom adalah kunci distribusi.
+ Kolom adalah bagian dari kunci sortir.
Jika tidak ada kolom tabel yang ditandai sebagai predikat, ANALISIS mencakup semua kolom, bahkan ketika KOLOM PREDIKAT ditentukan. Jika tidak ada kolom yang ditandai sebagai kolom predikat, mungkin karena tabel belum ditanyakan.
Anda dapat memilih untuk menggunakan KOLOM PREDIKAT ketika pola kueri beban kerja Anda relatif stabil. Ketika pola kueri bervariasi, dengan kolom yang berbeda sering digunakan sebagai predikat, menggunakan KOLOM PREDIKAT untuk sementara dapat menghasilkan statistik basi. Statistik basi dapat menyebabkan rencana runtime kueri suboptimal dan runtime yang lama. Namun, saat berikutnya Anda menjalankan ANALISIS menggunakan KOLOM PREDIKAT, kolom predikat baru disertakan.
Untuk melihat detail kolom predikat, gunakan SQL berikut untuk membuat tampilan bernama PREDICATE\$1COLUMNS.
```
CREATE VIEW predicate_columns AS
WITH predicate_column_info as (
SELECT ns.nspname AS schema_name, c.relname AS table_name, a.attnum as col_num, a.attname as col_name,
CASE
WHEN 10002 = s.stakind1 THEN array_to_string(stavalues1, '||')
WHEN 10002 = s.stakind2 THEN array_to_string(stavalues2, '||')
WHEN 10002 = s.stakind3 THEN array_to_string(stavalues3, '||')
WHEN 10002 = s.stakind4 THEN array_to_string(stavalues4, '||')
ELSE NULL::varchar
END AS pred_ts
FROM pg_statistic s
JOIN pg_class c ON c.oid = s.starelid
JOIN pg_namespace ns ON c.relnamespace = ns.oid
JOIN pg_attribute a ON c.oid = a.attrelid AND a.attnum = s.staattnum)
SELECT schema_name, table_name, col_num, col_name,
pred_ts NOT LIKE '2000-01-01%' AS is_predicate,
CASE WHEN pred_ts NOT LIKE '2000-01-01%' THEN (split_part(pred_ts, '||',1))::timestamp ELSE NULL::timestamp END as first_predicate_use,
CASE WHEN pred_ts NOT LIKE '%||2000-01-01%' THEN (split_part(pred_ts, '||',2))::timestamp ELSE NULL::timestamp END as last_analyze
FROM predicate_column_info;
```
Misalkan Anda menjalankan query berikut terhadap tabel LISTING. Perhatikan bahwa LISTID, LISTTIME, dan EVENTID digunakan dalam klausa join, filter, dan group by.
```
select s.buyerid,l.eventid, sum(l.totalprice)
from listing l
join sales s on l.listid = s.listid
where l.listtime > '2008-12-01'
group by l.eventid, s.buyerid;
```
Saat Anda menanyakan tampilan PREDICATE\$1COLUMNS, seperti yang ditunjukkan pada contoh berikut, Anda melihat bahwa LISTID, EVENTID, dan LISTTIME ditandai sebagai kolom predikat.
```
select * from predicate_columns
where table_name = 'listing';
```
```
schema_name | table_name | col_num | col_name | is_predicate | first_predicate_use | last_analyze
------------+------------+---------+----------------+--------------+---------------------+--------------------
public | listing | 1 | listid | true | 2017-05-05 19:27:59 | 2017-05-03 18:27:41
public | listing | 2 | sellerid | false | | 2017-05-03 18:27:41
public | listing | 3 | eventid | true | 2017-05-16 20:54:32 | 2017-05-03 18:27:41
public | listing | 4 | dateid | false | | 2017-05-03 18:27:41
public | listing | 5 | numtickets | false | | 2017-05-03 18:27:41
public | listing | 6 | priceperticket | false | | 2017-05-03 18:27:41
public | listing | 7 | totalprice | false | | 2017-05-03 18:27:41
public | listing | 8 | listtime | true | 2017-05-16 20:54:32 | 2017-05-03 18:27:41
```
Menjaga statistik terkini meningkatkan kinerja kueri dengan memungkinkan perencana kueri untuk memilih paket yang optimal. Amazon Redshift menyegarkan statistik secara otomatis di latar belakang, dan Anda juga dapat menjalankan perintah ANALYZE secara eksplisit. Jika Anda memilih untuk menjalankan ANALYSIS secara eksplisit, lakukan hal berikut:
+ Jalankan perintah ANALYZE sebelum menjalankan query.
+ Jalankan perintah ANALYZE pada database secara rutin di akhir setiap siklus pemuatan atau pembaruan reguler.
+ Jalankan perintah ANALYZE pada tabel baru yang Anda buat dan tabel atau kolom yang ada yang mengalami perubahan signifikan.
+ Pertimbangkan untuk menjalankan operasi ANALISIS pada jadwal yang berbeda untuk berbagai jenis tabel dan kolom, tergantung pada penggunaannya dalam kueri dan kecenderungannya untuk berubah.
+ Untuk menghemat waktu dan sumber daya cluster, gunakan klausa PREDICATE COLUMNS saat Anda menjalankan ANALYSIS.
Anda tidak perlu menjalankan perintah ANALYZE secara eksplisit setelah memulihkan snapshot ke cluster yang disediakan atau namespace tanpa server, atau setelah melanjutkan cluster penyediaan yang dijeda. Amazon Redshift menyimpan informasi tabel sistem dalam kasus ini, membuat perintah ANALYZE manual tidak diperlukan. Amazon Redshift akan terus menjalankan operasi analisis otomatis sesuai kebutuhan.
Operasi analisis melewatkan tabel yang memiliki up-to-date statistik. Jika Anda menjalankan ANALYZE sebagai bagian dari alur kerja ekstrak, transformasi, dan muat (ETL), analisis otomatis melewatkan tabel yang memiliki statistik saat ini. Demikian pula, ANALISIS eksplisit melewatkan tabel ketika analisis otomatis telah memperbarui statistik tabel.
## ANALISIS riwayat perintah
Ini berguna untuk mengetahui kapan perintah ANALYZE terakhir dijalankan pada tabel atau database. Saat perintah ANALYZE dijalankan, Amazon Redshift menjalankan beberapa kueri yang terlihat seperti ini:
```
padb_fetch_sample: select * from table_name
```
Kueri STL\$1ANALYZE untuk melihat riwayat operasi analisis. Jika Amazon Redshift menganalisis tabel menggunakan analisis otomatis, `is_background` kolom disetel ke `t` (true). Jika tidak, itu diatur ke `f` (false). Contoh berikut bergabung dengan STV\$1TBL\$1PERM untuk menunjukkan nama tabel dan rincian runtime.
```
select distinct a.xid, trim(t.name) as name, a.status, a.rows, a.modified_rows, a.starttime, a.endtime
from stl_analyze a
join stv_tbl_perm t on t.id=a.table_id
where name = 'users'
order by starttime;
xid | name | status | rows | modified_rows | starttime | endtime
-------+-------+-----------------+-------+---------------+---------------------+--------------------
1582 | users | Full | 49990 | 49990 | 2016-09-22 22:02:23 | 2016-09-22 22:02:28
244287 | users | Full | 24992 | 74988 | 2016-10-04 22:50:58 | 2016-10-04 22:51:01
244712 | users | Full | 49984 | 24992 | 2016-10-04 22:56:07 | 2016-10-04 22:56:07
245071 | users | Skipped | 49984 | 0 | 2016-10-04 22:58:17 | 2016-10-04 22:58:17
245439 | users | Skipped | 49984 | 1982 | 2016-10-04 23:00:13 | 2016-10-04 23:00:13
(5 rows)
```
Atau, Anda dapat menjalankan kueri yang lebih kompleks yang mengembalikan semua pernyataan yang berjalan di setiap transaksi selesai yang menyertakan perintah ANALISIS:
```
select xid, to_char(starttime, 'HH24:MM:SS.MS') as starttime,
datediff(sec,starttime,endtime ) as secs, substring(text, 1, 40)
from svl_statementtext
where sequence = 0
and xid in (select xid from svl_statementtext s where s.text like 'padb_fetch_sample%' )
order by xid desc, starttime;
xid | starttime | secs | substring
-----+--------------+------+------------------------------------------
1338 | 12:04:28.511 | 4 | Analyze date
1338 | 12:04:28.511 | 1 | padb_fetch_sample: select count(*) from
1338 | 12:04:29.443 | 2 | padb_fetch_sample: select * from date
1338 | 12:04:31.456 | 1 | padb_fetch_sample: select * from date
1337 | 12:04:24.388 | 1 | padb_fetch_sample: select count(*) from
1337 | 12:04:24.388 | 4 | Analyze sales
1337 | 12:04:25.322 | 2 | padb_fetch_sample: select * from sales
1337 | 12:04:27.363 | 1 | padb_fetch_sample: select * from sales
...
```
# Tabel penyedot debu
Amazon Redshift dapat secara otomatis mengurutkan dan melakukan operasi VACUUM DELETE pada tabel di latar belakang. Untuk membersihkan tabel setelah pemuatan atau serangkaian pembaruan tambahan, Anda juga dapat menjalankan [VAKUM](r_VACUUM_command.md) perintah, baik terhadap seluruh database atau terhadap tabel individual.
**catatan**
Hanya pengguna dengan izin tabel yang diperlukan yang dapat secara efektif menyedot tabel. Jika VACUUM dijalankan tanpa izin tabel yang diperlukan, operasi selesai dengan sukses tetapi tidak berpengaruh. Untuk daftar izin tabel yang valid untuk menjalankan VACUUM secara efektif, lihat[VAKUM](r_VACUUM_command.md).
Untuk alasan ini, kami merekomendasikan menyedot debu tabel individual sesuai kebutuhan. Kami juga merekomendasikan pendekatan ini karena menyedot debu seluruh database berpotensi menjadi operasi yang mahal.
## Penyortiran tabel otomatis
Amazon Redshift secara otomatis mengurutkan data di latar belakang untuk mempertahankan data tabel dalam urutan kunci sortir. Amazon Redshift melacak kueri pemindaian Anda untuk menentukan bagian tabel mana yang akan mendapat manfaat dari penyortiran. Amazon Redshift juga melacak kueri pemindaian dari cluster penskalaan konkurensi. Untuk arsitektur multi cluster yang menggunakan Amazon Redshift Data Sharing, Amazon Redshift juga melacak kueri pemindaian yang berasal dari clusters/workgroups konsumen di mesh data Anda, termasuk di berbagai wilayah. clusters/workgroups Statistik pemindaian dari cluster utama, cluster penskalaan konkurensi, dan cluster konsumen dikumpulkan untuk menentukan bagian tabel mana yang akan mendapat manfaat dari penyortiran.
Bergantung pada beban pada sistem, Amazon Redshift secara otomatis memulai pengurutan. Penyortiran otomatis ini mengurangi kebutuhan untuk menjalankan perintah VACUUM untuk menyimpan data dalam urutan kunci sortir. Jika Anda membutuhkan data yang sepenuhnya diurutkan dalam urutan kunci sortir, misalnya setelah pemuatan data yang besar, maka Anda masih dapat menjalankan perintah VACUUM secara manual. Untuk menentukan apakah tabel Anda akan mendapat manfaat dengan menjalankan VACUUM SORT, pantau `vacuum_sort_benefit` kolom di[SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md).
Amazon Redshift melacak kueri pemindaian yang menggunakan tombol sortir pada setiap tabel. Amazon Redshift memperkirakan persentase maksimum peningkatan dalam pemindaian dan pemfilteran data untuk setiap tabel (jika tabel diurutkan sepenuhnya). Perkiraan ini terlihat di `vacuum_sort_benefit` kolom di[SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Anda dapat menggunakan kolom ini, bersama dengan `unsorted` kolom, untuk menentukan kapan kueri dapat memperoleh manfaat dari menjalankan VACUUM SORT secara manual di atas meja. `unsorted`Kolom mencerminkan urutan fisik dari sebuah tabel. `vacuum_sort_benefit`Kolom menentukan dampak penyortiran tabel dengan menjalankan VACUUM SORT secara manual.
Misalnya, pertimbangkan kueri berikut:
```
select "table", unsorted,vacuum_sort_benefit from svv_table_info order by 1;
```
```
table | unsorted | vacuum_sort_benefit
-------+----------+---------------------
sales | 85.71 | 5.00
event | 45.24 | 67.00
```
Untuk tabel “penjualan”, meskipun tabel \$1 86% tidak disortir secara fisik, dampak kinerja kueri dari tabel yang 86% tidak disortir hanya 5%. Ini mungkin karena hanya sebagian kecil dari tabel yang diakses oleh kueri, atau sangat sedikit kueri yang mengakses tabel. Untuk tabel “acara”, tabel \$1 45% tidak disortir secara fisik. Tetapi dampak kinerja kueri sebesar 67% menunjukkan bahwa sebagian besar tabel diakses oleh kueri, atau jumlah kueri yang mengakses tabel besar. Tabel “acara” berpotensi mendapat manfaat dari menjalankan VACUUM SORT.
## Hapus vakum otomatis
Saat Anda melakukan penghapusan, baris ditandai untuk dihapus, tetapi tidak dihapus. Amazon Redshift secara otomatis menjalankan operasi VACUUM DELETE di latar belakang berdasarkan jumlah baris yang dihapus dalam tabel database. Amazon Redshift menjadwalkan VACUUM DELETE untuk berjalan selama periode pengurangan beban dan menghentikan operasi selama periode beban tinggi.
**Topics**
+ [Penyortiran tabel otomatis](#automatic-table-sort)
+ [Hapus vakum otomatis](#automatic-table-delete)
+ [Frekuensi VAKUM](#vacuum-frequency)
+ [Urutkan tahap dan gabungkan tahap](#vacuum-stages)
+ [Ambang vakum](#vacuum-sort-threshold)
+ [Jenis vakum](#vacuum-types)
+ [Meminimalkan waktu vakum](vacuum-managing-vacuum-times.md)
## Frekuensi VAKUM
Anda harus menyedot debu sesering yang diperlukan untuk mempertahankan kinerja kueri yang konsisten. Pertimbangkan faktor-faktor ini saat menentukan seberapa sering menjalankan perintah VACUUM Anda:
+ Jalankan VACUUM selama periode waktu ketika Anda mengharapkan aktivitas minimal di cluster, seperti malam hari atau selama jendela administrasi database yang ditentukan.
+ Jalankan perintah VACUUM di luar jendela pemeliharaan. Untuk informasi selengkapnya, lihat [Menjadwalkan di sekitar jendela pemeliharaan](https://docs.aws.amazon.com/redshift/latest/dg/c_best-practices-avoid-maintenance.html).
+ Wilayah besar yang tidak disortir menghasilkan waktu vakum yang lebih lama. Jika Anda menunda penyedot debu, vakum akan memakan waktu lebih lama karena lebih banyak data harus ditata ulang.
+ VACUUM adalah operasi I/O intensif, jadi semakin lama waktu yang dibutuhkan untuk menyelesaikan vakum Anda, semakin besar dampaknya pada kueri bersamaan dan operasi database lainnya yang berjalan di cluster Anda.
+ VACUUM membutuhkan waktu lebih lama untuk tabel yang menggunakan penyortiran interleaved. Untuk mengevaluasi apakah tabel yang disisipkan harus diurutkan ulang, kueri tampilan. [SVV\$1INTERLEAVED\$1COLUMNS](r_SVV_INTERLEAVED_COLUMNS.md)
## Urutkan tahap dan gabungkan tahap
Amazon Redshift melakukan operasi vakum dalam dua tahap: pertama, ia mengurutkan baris di wilayah yang tidak disortir, kemudian, jika perlu, ia menggabungkan baris yang baru diurutkan di akhir tabel dengan baris yang ada. Saat menyedot debu meja besar, operasi vakum berlangsung dalam serangkaian langkah yang terdiri dari jenis tambahan diikuti dengan penggabungan. Jika operasi gagal atau jika Amazon Redshift offline selama vakum, tabel atau database yang disedot sebagian akan berada dalam keadaan konsisten, tetapi Anda harus memulai ulang operasi vakum secara manual. Jenis tambahan hilang, tetapi baris gabungan yang dilakukan sebelum kegagalan tidak perlu disedot lagi. Jika wilayah yang tidak disortir besar, waktu yang hilang mungkin signifikan. Untuk informasi selengkapnya tentang tahapan pengurutan dan penggabungan, lihat[Kurangi volume baris gabungan](vacuum-managing-vacuum-times.md#vacuum-managing-volume-of-unmerged-rows).
Pengguna dapat mengakses tabel saat sedang disedot. Anda dapat melakukan kueri dan menulis operasi saat tabel sedang disedot, tetapi ketika DHTML dan vakum berjalan secara bersamaan, keduanya mungkin membutuhkan waktu lebih lama. Jika Anda menjalankan pernyataan UPDATE dan DELETE selama vakum, kinerja sistem mungkin berkurang. Penggabungan tambahan untuk sementara memblokir operasi UPDATE dan DELETE bersamaan, dan operasi UPDATE dan DELETE pada gilirannya memblokir sementara langkah penggabungan tambahan pada tabel yang terpengaruh. Operasi DDL, seperti ALTER TABLE, diblokir sampai operasi vakum selesai dengan tabel.
**catatan**
Berbagai pengubah untuk VACUUM mengontrol cara kerjanya. Anda dapat menggunakannya untuk menyesuaikan operasi vakum untuk kebutuhan saat ini. Misalnya, menggunakan VACUUM RECLUSTER memperpendek operasi vakum dengan tidak melakukan operasi penggabungan penuh. Untuk informasi selengkapnya, lihat [VAKUM](r_VACUUM_command.md).
## Ambang vakum
Secara default, VACUUM melewatkan fase pengurutan untuk tabel mana pun di mana lebih dari 95 persen baris tabel sudah diurutkan. Melewatkan fase pengurutan dapat secara signifikan meningkatkan kinerja VACUUM. Untuk mengubah ambang batas pengurutan default untuk satu tabel, sertakan nama tabel dan parameter TO *threshold* PERCENT saat Anda menjalankan perintah VACUUM.
## Jenis vakum
Untuk informasi tentang berbagai jenis vakum, lihat[VAKUM](r_VACUUM_command.md).
# Meminimalkan waktu vakum
Amazon Redshift secara otomatis mengurutkan data dan menjalankan VACUUM DELETE di latar belakang. Ini mengurangi kebutuhan untuk menjalankan perintah VACUUM. Menyedot debu berpotensi memakan waktu. Bergantung pada sifat data Anda, kami merekomendasikan praktik berikut untuk meminimalkan waktu vakum.
**Topics**
+ [Putuskan apakah akan mengindeks ulang](#r_vacuum-decide-whether-to-reindex)
+ [Kurangi ukuran wilayah yang tidak disortir](#r_vacuum_diskspacereqs)
+ [Kurangi volume baris gabungan](#vacuum-managing-volume-of-unmerged-rows)
+ [Muat data Anda dalam urutan kunci sortir](#vacuum-load-in-sort-key-order)
+ [Gunakan tabel deret waktu untuk mengurangi data yang tersimpan](#vacuum-time-series-tables)
## Putuskan apakah akan mengindeks ulang
Anda sering dapat meningkatkan kinerja kueri secara signifikan dengan menggunakan gaya pengurutan interleaved, tetapi seiring waktu kinerja mungkin menurun jika distribusi nilai dalam kolom kunci sortir berubah.
Saat Anda pertama kali memuat tabel interleaved kosong menggunakan COPY atau CREATE TABLE AS, Amazon Redshift secara otomatis membuat indeks interleaved. Jika Anda awalnya memuat tabel interleaved menggunakan INSERT, Anda perlu menjalankan VACUUM REINDEX setelahnya untuk menginisialisasi indeks interleaved.
Seiring waktu, saat Anda menambahkan baris dengan nilai kunci sortir baru, kinerja mungkin menurun jika distribusi nilai dalam kolom kunci sortir berubah. Jika baris baru Anda terutama berada dalam kisaran nilai kunci pengurutan yang ada, Anda tidak perlu mengindeks ulang. Jalankan VACUUM SORT ONLY atau VACUUM FULL untuk mengembalikan urutan pengurutan.
Mesin kueri dapat menggunakan urutan pengurutan untuk secara efisien memilih blok data mana yang perlu dipindai untuk memproses kueri. Untuk pengurutan interleaved, Amazon Redshift menganalisis nilai kolom kunci sortir untuk menentukan urutan pengurutan yang optimal. Jika distribusi nilai kunci berubah, atau miring, saat baris ditambahkan, strategi pengurutan tidak akan lagi optimal, dan manfaat kinerja penyortiran akan menurun. Untuk menganalisis ulang distribusi kunci sortir, Anda dapat menjalankan VACUUM REINDEX. Operasi reindex memakan waktu, jadi untuk memutuskan apakah sebuah tabel akan mendapat manfaat dari reindex, kueri tampilan. [SVV\$1INTERLEAVED\$1COLUMNS](r_SVV_INTERLEAVED_COLUMNS.md)
Misalnya, kueri berikut menunjukkan detail untuk tabel yang menggunakan kunci pengurutan interleaved.
```
select tbl as tbl_id, stv_tbl_perm.name as table_name,
col, interleaved_skew, last_reindex
from svv_interleaved_columns, stv_tbl_perm
where svv_interleaved_columns.tbl = stv_tbl_perm.id
and interleaved_skew is not null;
tbl_id | table_name | col | interleaved_skew | last_reindex
--------+------------+-----+------------------+--------------------
100048 | customer | 0 | 3.65 | 2015-04-22 22:05:45
100068 | lineorder | 1 | 2.65 | 2015-04-22 22:05:45
100072 | part | 0 | 1.65 | 2015-04-22 22:05:45
100077 | supplier | 1 | 1.00 | 2015-04-22 22:05:45
(4 rows)
```
Nilai untuk `interleaved_skew` adalah rasio yang menunjukkan jumlah kemiringan. Nilai 1 berarti tidak ada kemiringan. Jika kemiringan lebih besar dari 1,4, VACUUM REINDEX biasanya akan meningkatkan kinerja kecuali kemiringan melekat pada set yang mendasarinya.
Anda dapat menggunakan nilai tanggal `last_reindex` untuk menentukan berapa lama sejak reindex terakhir.
## Kurangi ukuran wilayah yang tidak disortir
Wilayah yang tidak disortir tumbuh ketika Anda memuat sejumlah besar data baru ke dalam tabel yang sudah berisi data atau ketika Anda tidak mengosongkan tabel sebagai bagian dari operasi pemeliharaan rutin Anda. Untuk menghindari operasi vakum yang berjalan lama, gunakan praktik berikut:
+ Jalankan operasi vakum pada jadwal reguler.
Jika Anda memuat tabel Anda secara bertahap (seperti pembaruan harian yang mewakili persentase kecil dari jumlah total baris dalam tabel), menjalankan VACUUM secara teratur akan membantu memastikan bahwa operasi vakum individu berjalan dengan cepat.
+ Jalankan beban terbesar terlebih dahulu.
Jika Anda perlu memuat tabel baru dengan beberapa operasi COPY, jalankan beban terbesar terlebih dahulu. Saat Anda menjalankan pemuatan awal ke tabel baru atau terpotong, semua data dimuat langsung ke wilayah yang diurutkan, jadi tidak diperlukan vakum.
+ Memotong tabel alih-alih menghapus semua baris.
Menghapus baris dari tabel tidak merebut kembali ruang yang ditempati baris sampai Anda melakukan operasi vakum; Namun, memotong tabel mengosongkan tabel dan merebut kembali ruang disk, sehingga tidak diperlukan ruang hampa. Atau, jatuhkan tabel dan buat kembali.
+ Memotong atau menjatuhkan tabel uji.
Jika Anda memuat sejumlah kecil baris ke dalam tabel untuk tujuan pengujian, jangan hapus baris setelah selesai. Sebagai gantinya, potong tabel dan muat ulang baris tersebut sebagai bagian dari operasi beban produksi berikutnya.
+ Lakukan salinan yang dalam.
Jika tabel yang menggunakan tabel kunci sortir majemuk memiliki wilayah besar yang tidak disortir, salinan dalam jauh lebih cepat daripada ruang hampa. Salinan mendalam membuat ulang dan mengisi ulang tabel dengan menggunakan sisipan massal, yang secara otomatis mengurutkan ulang tabel. Jika sebuah tabel memiliki wilayah besar yang tidak disortir, salinan dalam jauh lebih cepat daripada ruang hampa. Trade off adalah Anda tidak dapat membuat pembaruan bersamaan selama operasi penyalinan mendalam, yang dapat Anda lakukan selama ruang hampa. Untuk informasi selengkapnya, lihat [Praktik terbaik Amazon Redshift untuk mendesain kueri](c_designing-queries-best-practices.md).
## Kurangi volume baris gabungan
Jika operasi vakum perlu menggabungkan baris baru ke dalam wilayah yang diurutkan tabel, waktu yang diperlukan untuk ruang hampa akan meningkat seiring dengan bertambahnya tabel. Anda dapat meningkatkan kinerja vakum dengan mengurangi jumlah baris yang harus digabungkan.
Sebelum ruang hampa, tabel terdiri dari wilayah yang diurutkan di kepala tabel, diikuti oleh wilayah yang tidak disortir, yang tumbuh setiap kali baris ditambahkan atau diperbarui. Ketika satu set baris ditambahkan oleh operasi COPY, kumpulan baris baru diurutkan pada kunci sortir karena ditambahkan ke wilayah yang tidak disortir di akhir tabel. Baris baru diurutkan dalam set mereka sendiri, tetapi tidak dalam wilayah yang tidak disortir.
Diagram berikut menggambarkan wilayah yang tidak disortir setelah dua operasi COPY berturut-turut, di mana kunci sortir adalah CUSTID. Untuk mempermudah, contoh ini menunjukkan kunci sortir majemuk, tetapi prinsip yang sama berlaku untuk kunci sortir yang disisipkan, kecuali bahwa dampak wilayah yang tidak disortir lebih besar untuk tabel yang disisipkan.
![\[Tabel yang tidak disortir menyimpan catatan dari dua operasi COPY.\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/images/vacuum-unsorted-region.png)
Vakum mengembalikan urutan tabel dalam dua tahap:
1. Urutkan wilayah yang tidak disortir menjadi wilayah yang baru diurutkan.
Tahap pertama relatif murah, karena hanya wilayah yang tidak disortir yang ditulis ulang. Jika rentang nilai kunci sortir dari wilayah yang baru diurutkan lebih tinggi dari rentang yang ada, hanya baris baru yang perlu ditulis ulang, dan ruang hampa selesai. Misalnya, jika wilayah yang diurutkan berisi nilai ID 1 hingga 500 dan operasi penyalinan berikutnya menambahkan nilai kunci yang lebih besar dari 500, maka hanya wilayah yang tidak disortir yang perlu ditulis ulang.
1. Gabungkan wilayah yang baru diurutkan dengan wilayah yang telah diurutkan sebelumnya.
Jika kunci di wilayah yang baru diurutkan tumpang tindih dengan kunci di wilayah yang diurutkan, maka VACUUM perlu menggabungkan baris. Mulai dari awal wilayah yang baru diurutkan (pada kunci pengurutan terendah), ruang hampa menulis baris gabungan dari wilayah yang diurutkan sebelumnya dan wilayah yang baru diurutkan ke dalam kumpulan blok baru.
Sejauh mana rentang kunci sortir baru tumpang tindih dengan kunci pengurutan yang ada menentukan sejauh mana wilayah yang diurutkan sebelumnya perlu ditulis ulang. Jika kunci yang tidak disortir tersebar di seluruh rentang pengurutan yang ada, ruang hampa mungkin perlu menulis ulang bagian tabel yang ada.
Diagram berikut menunjukkan bagaimana vakum akan mengurutkan dan menggabungkan baris yang ditambahkan ke tabel di mana CUSTID adalah kunci sortir. Karena setiap operasi penyalinan menambahkan satu set baris baru dengan nilai kunci yang tumpang tindih dengan kunci yang ada, hampir seluruh tabel perlu ditulis ulang. Diagram menunjukkan pengurutan tunggal dan penggabungan, tetapi dalam praktiknya, ruang hampa besar terdiri dari serangkaian langkah pengurutan dan penggabungan tambahan.
![\[Operasi VACUUM pada tabel contoh dalam dua langkah. Pertama baris baru diurutkan, lalu digabungkan dengan baris yang ada.\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/images/vacuum-unsorted-region-sort-merge.png)
Jika rentang kunci sortir dalam satu set baris baru tumpang tindih dengan kisaran kunci yang ada, biaya tahap penggabungan terus tumbuh sebanding dengan ukuran tabel saat tabel tumbuh sementara biaya tahap pengurutan tetap sebanding dengan ukuran wilayah yang tidak disortir. Dalam kasus seperti itu, biaya tahap penggabungan membayangi biaya tahap pengurutan, seperti yang ditunjukkan diagram berikut.
![\[Diagram yang menunjukkan bagaimana tahap penggabungan menjadi lebih mahal ketika baris baru memiliki kunci pengurutan yang tumpang tindih dengan baris yang ada.\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/images/vacuum-example-merge-region-grows.png)
Untuk menentukan proporsi tabel yang digabungkan ulang, kueri SVV\$1VACUUM\$1SUMMARY setelah operasi vakum selesai. Kueri berikut menunjukkan efek dari enam vakum berturut-turut karena CUSTSALES tumbuh lebih besar dari waktu ke waktu.
```
select * from svv_vacuum_summary
where table_name = 'custsales';
table_name | xid | sort_ | merge_ | elapsed_ | row_ | sortedrow_ | block_ | max_merge_
| | partitions | increments | time | delta | delta | delta | partitions
-----------+------+------------+------------+------------+-------+------------+---------+---------------
custsales | 7072 | 3 | 2 | 143918314 | 0 | 88297472 | 1524 | 47
custsales | 7122 | 3 | 3 | 164157882 | 0 | 88297472 | 772 | 47
custsales | 7212 | 3 | 4 | 187433171 | 0 | 88297472 | 767 | 47
custsales | 7289 | 3 | 4 | 255482945 | 0 | 88297472 | 770 | 47
custsales | 7420 | 3 | 5 | 316583833 | 0 | 88297472 | 769 | 47
custsales | 9007 | 3 | 6 | 306685472 | 0 | 88297472 | 772 | 47
(6 rows)
```
Kolom merge\$1increments memberikan indikasi jumlah data yang digabungkan untuk setiap operasi vakum. Jika jumlah kenaikan penggabungan selama vakum berturut-turut meningkat sebanding dengan pertumbuhan ukuran tabel, ini menunjukkan bahwa setiap operasi vakum menggabungkan kembali peningkatan jumlah baris dalam tabel karena daerah yang ada dan yang baru diurutkan tumpang tindih.
## Muat data Anda dalam urutan kunci sortir
Jika Anda memuat data Anda dalam urutan kunci sortir menggunakan perintah COPY, Anda dapat mengurangi atau bahkan menghapus kebutuhan untuk menyedot debu.
COPY secara otomatis menambahkan baris baru ke wilayah tabel yang diurutkan ketika semua hal berikut benar:
+ Tabel menggunakan kunci sortir majemuk dengan hanya satu kolom sortir.
+ Kolom sortir BUKAN NULL.
+ Tabel 100 persen diurutkan atau kosong.
+ Semua baris baru lebih tinggi dalam urutan pengurutan daripada baris yang ada, termasuk baris yang ditandai untuk dihapus. Dalam hal ini, Amazon Redshift menggunakan delapan byte pertama dari kunci sortir untuk menentukan urutan pengurutan.
+ Perintah COPY tidak memicu optimasi beban tertentu. Saat memuat volume data yang besar, Amazon Redshift mungkin mengoptimalkan kinerja dengan membuat partisi baru yang diurutkan daripada menambahkan baris ke wilayah tabel yang diurutkan.
Misalnya, Anda memiliki tabel yang mencatat peristiwa pelanggan menggunakan ID pelanggan dan waktu. Jika Anda mengurutkan ID pelanggan, kemungkinan rentang kunci pengurutan baris baru yang ditambahkan oleh beban tambahan akan tumpang tindih dengan rentang yang ada, seperti yang ditunjukkan pada contoh sebelumnya, yang mengarah ke operasi vakum yang mahal.
Jika Anda mengatur kunci pengurutan ke kolom stempel waktu, baris baru Anda akan ditambahkan dalam urutan pengurutan di akhir tabel, seperti yang ditunjukkan diagram berikut, mengurangi atau bahkan menghilangkan kebutuhan untuk menyedot debu.
![\[Tabel yang menggunakan kolom timestamp sebagai kunci pengurutan, mendapatkan catatan baru yang tidak perlu diurutkan.\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/images/vacuum-unsorted-region-date-sort.png)
## Gunakan tabel deret waktu untuk mengurangi data yang tersimpan
Jika Anda memelihara data untuk periode waktu bergulir, gunakan serangkaian tabel, seperti yang diilustrasikan diagram berikut.
![\[Lima tabel dengan data dari lima kuartal. Tabel tertua dihapus untuk mempertahankan satu tahun waktu bergulir.\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/images/vacuum-example-unsorted-region-copy-time-series.png)
Buat tabel baru setiap kali Anda menambahkan satu set data, lalu hapus tabel tertua dalam seri. Anda mendapatkan manfaat ganda:
+ Anda menghindari biaya tambahan untuk menghapus baris, karena operasi DROP TABLE jauh lebih efisien daripada DELETE massal.
+ Jika tabel diurutkan berdasarkan stempel waktu, tidak diperlukan vakum. Jika setiap tabel berisi data selama satu bulan, ruang hampa paling banyak harus menulis ulang data selama satu bulan, bahkan jika tabel tidak diurutkan berdasarkan stempel waktu.
Anda dapat membuat tampilan UNION ALL untuk digunakan dengan melaporkan kueri yang menyembunyikan fakta bahwa data disimpan dalam beberapa tabel. Jika kueri memfilter pada kunci pengurutan, perencana kueri dapat secara efisien melewati semua tabel yang tidak digunakan. UNION ALL bisa kurang efisien untuk jenis kueri lainnya, jadi Anda harus mengevaluasi kinerja kueri dalam konteks semua kueri yang menggunakan tabel.
# Mengelola operasi tulis bersamaan
Beberapa aplikasi tidak hanya memerlukan kueri dan pemuatan bersamaan, tetapi juga kemampuan untuk menulis ke beberapa tabel atau tabel yang sama secara bersamaan. Dalam konteks ini, *secara bersamaan* berarti tumpang tindih, tidak dijadwalkan untuk berjalan pada waktu yang bersamaan. Dua transaksi dianggap bersamaan jika yang kedua dimulai sebelum komitmen pertama. Operasi bersamaan dapat berasal dari sesi berbeda yang dikendalikan baik oleh pengguna yang sama atau oleh pengguna yang berbeda.
Amazon Redshift mendukung jenis aplikasi ini dengan memungkinkan tabel dibaca saat sedang dimuat atau dimodifikasi secara bertahap. Kueri hanya melihat versi komit terbaru, atau *snapshot*, dari data, daripada menunggu versi berikutnya untuk dilakukan. Jika Anda ingin kueri tertentu menunggu komit dari operasi penulisan lain, Anda harus menjadwalkannya sesuai.
**catatan**
Amazon Redshift mendukung perilaku *komit otomatis default di mana masing-masing menjalankan komit* perintah SQL secara terpisah satu per satu. Jika Anda melampirkan satu set perintah dalam blok transaksi (didefinisikan oleh [MULAI](r_BEGIN.md) dan [AKHIR](r_END.md) pernyataan), blok tersebut melakukan sebagai satu transaksi, sehingga Anda dapat memutar kembali jika perlu. Pengecualian untuk perilaku ini adalah perintah TRUNCATE dan VACUUM, yang secara otomatis melakukan semua perubahan yang belum selesai yang dibuat dalam transaksi saat ini.
Beberapa klien SQL mengeluarkan perintah BEGIN dan COMMIT secara otomatis, sehingga klien mengontrol apakah sekelompok pernyataan dijalankan sebagai transaksi atau setiap pernyataan individu dijalankan sebagai transaksinya sendiri. Periksa dokumentasi untuk antarmuka yang Anda gunakan. Misalnya, saat menggunakan driver Amazon Redshift JDBC, JDBC `PreparedStatement` dengan string kueri yang berisi beberapa perintah SQL (dipisahkan titik koma) menjalankan semua pernyataan sebagai satu transaksi. Sebaliknya, jika Anda menggunakan SQL Workbench/J dan mengatur AUTO COMMIT ON, maka jika Anda menjalankan beberapa pernyataan, setiap pernyataan berjalan sebagai transaksinya sendiri.
Topik berikut menjelaskan beberapa konsep kunci dan kasus penggunaan yang melibatkan transaksi, snapshot database, pembaruan, dan perilaku bersamaan.
**Topics**
+ [Tingkat isolasi di Amazon Redshift](c_serial_isolation.md)
+ [Menulis dan read/write operasi](c_write_readwrite.md)
+ [Contoh tulis bersamaan](r_Serializable_isolation_example.md)
+ [Memecahkan masalah kesalahan isolasi serial](c_serial_isolation-serializable-isolation-troubleshooting.md)
# Tingkat isolasi di Amazon Redshift
Operasi penulisan bersamaan didukung di Amazon Redshift dengan cara protektif, menggunakan kunci tulis pada tabel dan *prinsip isolasi serial.* Isolasi serializable mempertahankan ilusi bahwa transaksi yang berjalan melawan tabel adalah satu-satunya transaksi yang berjalan melawan tabel itu.
Basis data Amazon Redshift mendukung operasi penulisan bersamaan dengan meminta setiap operasi menggunakan versi komit terbaru, atau snapshot, dari data mereka pada awal transaksi. Sebuah snapshot database dibuat dalam transaksi pada kemunculan pertama dari sebagian besar pernyataan SELECT, perintah DMLseperti COPY, DELETE, INSERT, UPDATE, dan TRUNCATE, dan perintah DDL berikut:
+ ALTER TABLE (untuk menambah atau menjatuhkan kolom)
+ CREATE TABLE
+ MEJA DROP
+ MEMOTONG TABEL
Tidak ada transaksi lain yang dapat mengubah snapshot ini, artinya transaksi terisolasi satu sama lain. Artinya, transaksi bersamaan tidak terlihat satu sama lain dan tidak dapat mendeteksi perubahan satu sama lain.
Eksekusi transaksi bersamaan harus menghasilkan hasil yang sama dengan eksekusi serial dari transaksi tersebut. Jika tidak ada eksekusi serial dari transaksi tersebut yang dapat menghasilkan hasil yang sama, transaksi yang menjalankan pernyataan yang mungkin merusak kemampuan untuk membuat serial dihentikan dan digulung kembali.
Misalnya, pengguna mencoba menjalankan dua transaksi bersamaan, T1 dan T2. Menjalankan T1 dan T2 harus menghasilkan hasil yang sama dengan setidaknya salah satu skenario berikut:
+ T1 dan T2 berjalan secara serial dalam urutan itu.
+ T2 dan T1 berjalan secara serial dalam urutan itu.
Tingkat isolasi di Amazon Redshift mencegah masalah berikut:
+ Pembacaan kotor - Pembacaan kotor terjadi ketika transaksi membaca data yang belum dilakukan. Misalnya, transaksi 1 memperbarui baris. Transaksi 2 membaca baris yang diperbarui sebelum T1 melakukan pembaruan. Jika T1 mengembalikan perubahan, T2 akan membaca data dalam baris yang tidak terikat yang sekarang dianggap Amazon Redshift tidak pernah ada.
+ Pembacaan yang tidak dapat diulang - Pembacaan yang tidak dapat diulang terjadi ketika satu transaksi membaca baris yang sama dua kali tetapi mendapatkan data yang berbeda setiap kali. Misalnya, transaksi 1 membaca satu baris. Transaksi 2 memperbarui atau menghapus baris itu dan melakukan pembaruan atau penghapusan. Jika T1 membaca ulang baris, ia mengambil nilai baris yang berbeda atau menemukan bahwa baris telah dihapus.
+ Phantom adalah baris yang cocok dengan kriteria pencarian tetapi awalnya tidak terlihat. Misalnya, transaksi 1 membaca satu set baris yang memenuhi kriteria pencariannya. Transaksi 2 menghasilkan baris baru dalam pernyataan UPDATE atau INSERT yang cocok dengan kriteria pencarian untuk T1. Jika T1 menjalankan kembali pernyataan pencariannya, ia mendapat serangkaian baris yang berbeda.
## Isolasi SNAPSHOT dan SERIALIZABLE
Isolasi SNAPSHOT dan SERIALIZABLE adalah dua tingkat isolasi serial yang tersedia di Amazon Redshift.
Isolasi SNAPSHOT adalah tingkat isolasi default saat membuat cluster yang disediakan dan grup kerja tanpa server, memungkinkan Anda memproses volume data yang lebih besar daripada isolasi SERIALIZABLE dalam waktu yang lebih singkat.
Isolasi SERIALIZABLE membutuhkan lebih banyak waktu, tetapi menerapkan batasan yang lebih ketat pada transaksi bersamaan. Tingkat isolasi ini mencegah masalah seperti anomali write-skew dengan hanya mengizinkan satu transaksi untuk dilakukan, sementara membatalkan semua transaksi bersamaan lainnya dengan kesalahan pelanggaran isolasi serializable.
Berikut ini adalah contoh timeline tentang bagaimana dua operasi penulisan bersamaan akan ditangani saat menggunakan isolasi SNAPSHOT. Setiap pernyataan UPDATE pengguna diizinkan untuk melakukan komit karena mereka tidak bertentangan dengan mencoba memperbarui baris yang sama.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/c_serial_isolation.html)
Jika skenario yang sama dijalankan menggunakan isolasi serial, Amazon Redshift menghentikan pengguna 2 karena pelanggaran serial dan mengembalikan kesalahan. `1023` Untuk informasi selengkapnya, lihat [Memecahkan masalah kesalahan isolasi serial](c_serial_isolation-serializable-isolation-troubleshooting.md). Dalam hal ini, hanya pengguna 1 yang dapat melakukan komit dengan sukses.
## Pertimbangan-pertimbangan
Saat menggunakan tingkat isolasi di Amazon Redshift, pertimbangkan hal berikut:
+ Kueri tampilan katalog STV\$1DB\$1ISOLATION\$1LEVEL untuk melihat tingkat isolasi yang digunakan database Anda. Untuk informasi selengkapnya, lihat [STV\$1DB\$1ISOLASI\$1TINGKAT](r_STV_DB_ISOLATION_LEVEL.md).
+ Kueri tampilan PG\$1DATABASE\$1INFO untuk melihat berapa banyak transaksi bersamaan yang didukung untuk database Anda. Untuk informasi selengkapnya, lihat [PG\$1DATABASE\$1INFO](r_PG_DATABASE_INFO.md).
+ Tabel katalog sistem (PG) dan tabel sistem Amazon Redshift lainnya tidak terkunci dalam transaksi. Oleh karena itu, perubahan pada objek database yang muncul dari operasi DDL dan TRUNCATE terlihat pada komit untuk setiap transaksi bersamaan.
Misalnya, anggaplah tabel A ada dalam database ketika dua transaksi bersamaan, T1 dan T2, dimulai. Misalkan T2 mengembalikan daftar tabel dengan memilih dari tabel katalog PG\$1TABLES. Kemudian T1 menjatuhkan tabel A dan komit, lalu T2 mencantumkan tabel lagi. Tabel A sekarang tidak lagi terdaftar. Jika T2 mencoba menanyakan tabel yang dijatuhkan, Amazon Redshift mengembalikan kesalahan “relasi tidak ada”. Kueri katalog yang mengembalikan daftar tabel ke T2 atau memeriksa bahwa tabel A ada tidak tunduk pada aturan isolasi yang sama seperti operasi yang dilakukan pada tabel pengguna.
Transaksi untuk pembaruan tabel ini berjalan dalam mode isolasi komited baca.
+ Tabel katalog awalan PG tidak mendukung isolasi SNAPSHOT.
# Menulis dan read/write operasi
Anda dapat mengelola perilaku spesifik operasi penulisan bersamaan dengan memutuskan kapan dan bagaimana menjalankan berbagai jenis perintah. Perintah berikut relevan dengan diskusi ini:
+ perintah COPY, yang melakukan beban (awal atau inkremental)
+ INSERT perintah yang menambahkan satu atau beberapa baris pada satu waktu
+ Perintah UPDATE, yang memodifikasi baris yang ada
+ DELETE perintah, yang menghapus baris
Operasi COPY dan INSERT adalah operasi penulisan murni. Operasi DELETE dan UPDATE adalah read/write operasi (untuk baris yang akan dihapus atau diperbarui, mereka harus dibaca terlebih dahulu). Hasil operasi penulisan bersamaan bergantung pada perintah spesifik yang sedang dijalankan secara bersamaan.
Operasi UPDATE dan DELETE berperilaku berbeda karena mereka mengandalkan pembacaan tabel awal sebelum mereka melakukan penulisan apa pun. Mengingat bahwa transaksi bersamaan tidak terlihat satu sama lain, keduanya UPDATEs dan DELETEs harus membaca snapshot data dari komit terakhir. Ketika UPDATE atau DELETE pertama melepaskan kuncinya, UPDATE atau DELETE kedua perlu menentukan apakah data yang akan digunakan berpotensi basi. Itu tidak akan basi, karena transaksi kedua tidak mendapatkan snapshot datanya sampai setelah transaksi pertama merilis kuncinya.
## Potensi situasi kebuntuan untuk transaksi tulis bersamaan yang melibatkan beberapa tabel
Ketika transaksi melibatkan pembaruan lebih dari satu tabel, selalu ada kemungkinan transaksi yang berjalan secara bersamaan menjadi menemui jalan buntu ketika keduanya mencoba menulis ke set tabel yang sama. Sebuah transaksi melepaskan semua kunci tabelnya sekaligus ketika melakukan atau memutar kembali; itu tidak melepaskan kunci satu per satu.
Misalnya, transaksi T1 dan T2 dimulai pada waktu yang hampir bersamaan. Jika T1 mulai menulis ke tabel A dan T2 mulai menulis ke tabel B, kedua transaksi dapat dilanjutkan tanpa konflik. Namun, jika T1 selesai menulis ke tabel A dan perlu mulai menulis ke tabel B, itu tidak akan dapat melanjutkan karena T2 masih memegang kunci pada B. Demikian pula, jika T2 selesai menulis ke tabel B dan perlu mulai menulis ke tabel A, itu tidak akan dapat melanjutkan baik karena T1 masih memegang kunci pada A. Karena tidak ada transaksi yang dapat melepaskan kunci sampai semua operasi penulisannya dilakukan, tidak ada transaksi yang dapat dilanjutkan. Untuk menghindari kebuntuan semacam ini, Anda perlu menjadwalkan operasi penulisan bersamaan dengan hati-hati. Misalnya, Anda harus selalu memperbarui tabel dalam urutan yang sama dalam transaksi dan, jika menentukan kunci, mengunci tabel dalam urutan yang sama sebelum Anda melakukan operasi DML apa pun.
## Potensi situasi kebuntuan untuk transaksi tulis bersamaan yang melibatkan satu tabel
Dalam lingkungan isolasi snapshot, kebuntuan dapat terjadi saat menjalankan transaksi tulis bersamaan pada tabel yang sama. Kebuntuan isolasi snapshot terjadi ketika pernyataan INSERT atau COPY bersamaan berbagi kunci dan membuat kemajuan, dan pernyataan lain perlu melakukan operasi (UPDATE, DELETE, MERGE, atau operasi DDL) yang memerlukan kunci eksklusif pada tabel yang sama.
Pertimbangkan skenario berikut:
Transaksi 1 (T1):
```
INSERT/COPY INTO table_A;
```
Transaksi 2 (T2):
```
INSERT/COPY INTO table_A;
table_A
```
Kebuntuan dapat terjadi ketika beberapa transaksi dengan operasi INSERT atau COPY berjalan bersamaan pada tabel yang sama dengan kunci bersama, dan salah satu transaksi tersebut mengikuti operasi tulis murni dengan operasi yang memerlukan kunci eksklusif, seperti pernyataan UPDATE, MERGE, DELETE, atau DDL.
Untuk menghindari kebuntuan dalam situasi ini, Anda dapat memisahkan pernyataan yang membutuhkan kunci eksklusif (UPDATE/MERGE/DELETE/DDL statements) to a different transaction so that any INSERT/COPY statements can progress simultaneously, and the statements requiring exclusive locks can execute after them. Alternatively, for transactions with INSERT/COPY statements and MERGE/UPDATE/MERGEpernyataan pada tabel yang sama, Anda dapat menyertakan logika coba lagi dalam aplikasi Anda untuk mengatasi potensi kebuntuan.
# Contoh tulis bersamaan
Contoh pseudo-code berikut menunjukkan bagaimana transaksi berjalan atau menunggu saat dijalankan secara bersamaan.
## Contoh tulis bersamaan dengan isolasi serial
### Operasi COPY bersamaan ke dalam tabel yang sama dengan isolasi serial
Transaksi 1 salinan baris ke dalam tabel LISTING:
```
begin;
copy listing from ...;
end;
```
Transaksi 2 dimulai secara bersamaan dalam sesi terpisah dan mencoba menyalin lebih banyak baris ke dalam tabel LISTING. Transaksi 2 harus menunggu hingga transaksi 1 melepaskan kunci tulis pada tabel LISTING, kemudian dapat dilanjutkan.
```
begin;
[waits]
copy listing from ;
end;
```
Perilaku yang sama akan terjadi jika salah satu atau kedua transaksi berisi perintah INSERT alih-alih perintah COPY.
### Operasi DELETE bersamaan dari tabel yang sama dengan isolasi serial
Transaksi 1 menghapus baris dari tabel:
```
begin;
delete from listing where ...;
end;
```
Transaksi 2 dimulai secara bersamaan dan mencoba menghapus baris dari tabel yang sama. Ini akan berhasil karena menunggu transaksi 1 selesai sebelum mencoba menghapus baris.
```
begin
[waits]
delete from listing where ;
end;
```
Perilaku yang sama akan terjadi jika salah satu atau kedua transaksi berisi perintah UPDATE ke tabel yang sama, bukan perintah DELETE.
### Transaksi bersamaan dengan campuran operasi baca dan tulis dengan isolasi serial
Dalam contoh ini, transaksi 1 menghapus baris dari tabel USERS, memuat ulang tabel, menjalankan kueri COUNT (\$1), dan kemudian ANALISIS, sebelum melakukan:
```
begin;
delete one row from USERS table;
copy ;
select count(*) from users;
analyze ;
end;
```
Sementara itu, transaksi 2 dimulai. Transaksi ini mencoba menyalin baris tambahan ke dalam tabel USERS, menganalisis tabel, dan kemudian menjalankan kueri COUNT (\$1) yang sama dengan transaksi pertama:
```
begin;
[waits]
copy users from ...;
select count(*) from users;
analyze;
end;
```
Transaksi kedua akan berhasil karena harus menunggu yang pertama selesai. Kueri COUNT-nya akan mengembalikan hitungan berdasarkan beban yang telah diselesaikan.
## Contoh tulis bersamaan dengan isolasi snapshot
### Operasi COPY bersamaan ke dalam tabel yang sama dengan isolasi snapshot
Transaksi 1 salinan baris ke dalam tabel LISTING:
```
begin;
copy listing from ...;
end;
```
Transaksi 2 dimulai secara bersamaan dalam sesi terpisah dan mencoba menyalin lebih banyak baris ke dalam tabel LISTING. Transaksi 2 dapat berkembang secara bersamaan hingga salah satu transaksi perlu menulis data ke tabel target`listing`, di mana mereka akan berjalan secara berurutan.
```
begin;
//When the COPY statement from T1 needs to write data to the table, the COPY statement from T2 waits.
copy listing from ...;
end;
```
Perilaku yang sama akan terjadi jika salah satu atau kedua transaksi berisi perintah INSERT alih-alih perintah COPY.
### Operasi DELETE bersamaan dari tabel yang sama dengan isolasi snapshot
Operasi DELETE atau UPDATE bersamaan dari tabel yang sama dengan isolasi snapshot berjalan sama seperti operasi yang dijalankan dengan isolasi serializable.
### Transaksi bersamaan dengan campuran operasi baca dan tulis dengan isolasi snapshot
Transaksi bersamaan yang dijalankan dengan campuran operasi dengan isolasi snapshot berjalan sama seperti transaksi dengan campuran operasi yang dijalankan dengan isolasi serializable.
# Memecahkan masalah kesalahan isolasi serial
## ERROR:1023 DETAIL: Pelanggaran isolasi serial di atas meja di Redshift
Saat Amazon Redshift mendeteksi kesalahan isolasi yang dapat diserialisasi, Anda akan melihat pesan kesalahan seperti berikut ini.
```
ERROR:1023 DETAIL: Serializable isolation violation on table in Redshift
```
Untuk mengatasi kesalahan isolasi serializable, Anda dapat mencoba metode berikut:
+ Coba lagi transaksi yang dibatalkan.
Amazon Redshift mendeteksi bahwa beban kerja bersamaan tidak dapat diserialkan. Ini menunjukkan celah dalam logika aplikasi, yang biasanya dapat diatasi dengan mencoba kembali transaksi yang mengalami kesalahan. Jika masalah berlanjut, coba salah satu metode lain.
+ Pindahkan operasi apa pun yang tidak harus berada dalam transaksi atom yang sama di luar transaksi.
Metode ini berlaku ketika operasi individu dalam dua transaksi saling merujuk satu sama lain dengan cara yang dapat mempengaruhi hasil transaksi lainnya. Misalnya, dua sesi berikut masing-masing memulai transaksi.
```
Session1_Redshift=# begin;
```
```
Session2_Redshift=# begin;
```
Hasil dari pernyataan SELECT dalam setiap transaksi mungkin dipengaruhi oleh pernyataan INSERT di yang lain. Dengan kata lain, anggaplah Anda menjalankan pernyataan berikut secara serial, dalam urutan apa pun. Dalam setiap kasus, hasilnya adalah salah satu pernyataan SELECT mengembalikan satu baris lebih banyak daripada jika transaksi dijalankan secara bersamaan. Tidak ada urutan di mana operasi dapat berjalan secara serial yang menghasilkan hasil yang sama seperti ketika dijalankan secara bersamaan. Dengan demikian, operasi terakhir yang dijalankan menghasilkan kesalahan isolasi serial.
```
Session1_Redshift=# select * from tab1;
Session1_Redshift=# insert into tab2 values (1);
```
```
Session2_Redshift=# insert into tab1 values (1);
Session2_Redshift=# select * from tab2;
```
Dalam banyak kasus, hasil dari pernyataan SELECT tidak penting. Dengan kata lain, atomisitas operasi dalam transaksi tidak penting. Dalam kasus ini, pindahkan pernyataan SELECT di luar transaksi mereka, seperti yang ditunjukkan pada contoh berikut.
```
Session1_Redshift=# begin;
Session1_Redshift=# insert into tab1 values (1)
Session1_Redshift=# end;
Session1_Redshift=# select * from tab2;
```
```
Session2_Redshift # select * from tab1;
Session2_Redshift=# begin;
Session2_Redshift=# insert into tab2 values (1)
Session2_Redshift=# end;
```
Dalam contoh ini, tidak ada referensi silang dalam transaksi. Kedua pernyataan INSERT tidak saling mempengaruhi. Dalam contoh ini, setidaknya ada satu urutan di mana transaksi dapat berjalan secara serial dan menghasilkan hasil yang sama seolah-olah dijalankan secara bersamaan. Ini berarti bahwa transaksi dapat diserialkan.
+ Paksa serialisasi dengan mengunci semua tabel di setiap sesi.
[GEMBOK](r_LOCK.md)Perintah memblokir operasi yang dapat mengakibatkan kesalahan isolasi serializable. Saat Anda menggunakan perintah LOCK, pastikan untuk melakukan hal berikut:
+ Kunci semua tabel yang terpengaruh oleh transaksi, termasuk yang terpengaruh oleh pernyataan SELECT hanya-baca di dalam transaksi.
+ Kunci tabel dalam urutan yang sama, terlepas dari urutan operasi yang dilakukan.
+ Kunci semua tabel di awal transaksi, sebelum melakukan operasi apa pun.
+ Gunakan isolasi snapshot untuk transaksi bersamaan
Gunakan perintah ALTER DATABASE dengan isolasi snapshot. Untuk informasi selengkapnya tentang parameter SNAPSHOT untuk ALTER DATABASE, lihat. [Parameter](r_ALTER_DATABASE.md#r_ALTER_DATABASE-parameters)
## ERROR:1018 DETAIL: Relasi tidak ada
Saat menjalankan operasi Amazon Redshift bersamaan di sesi yang berbeda, Anda akan melihat pesan galat seperti berikut ini.
```
ERROR: 1018 DETAIL: Relation does not exist.
```
Transaksi di Amazon Redshift mengikuti isolasi snapshot. Setelah transaksi dimulai, Amazon Redshift mengambil snapshot dari database. Untuk seluruh siklus hidup transaksi, transaksi beroperasi pada status database sebagaimana tercermin dalam snapshot. Jika transaksi membaca dari tabel yang tidak ada dalam snapshot, itu akan menampilkan pesan kesalahan 1018 yang ditunjukkan sebelumnya. Bahkan ketika transaksi bersamaan lainnya membuat tabel setelah transaksi mengambil snapshot, transaksi tidak dapat membaca dari tabel yang baru dibuat.
Untuk mengatasi kesalahan isolasi serialisasi ini, Anda dapat mencoba memindahkan awal transaksi ke titik di mana Anda tahu tabel itu ada.
Jika tabel dibuat oleh transaksi lain, poin ini setidaknya setelah transaksi dilakukan. Juga, pastikan bahwa tidak ada transaksi bersamaan yang dilakukan yang mungkin telah menjatuhkan tabel.
```
session1 = # BEGIN;
session1 = # DROP TABLE A;
session1 = # COMMIT;
```
```
session2 = # BEGIN;
```
```
session3 = # BEGIN;
session3 = # CREATE TABLE A (id INT);
session3 = # COMMIT;
```
```
session2 = # SELECT * FROM A;
```
Operasi terakhir yang dijalankan sebagai operasi baca oleh session2 menghasilkan kesalahan isolasi serial. Kesalahan ini terjadi ketika session2 mengambil snapshot dan tabel telah dijatuhkan oleh sesi komitmen1. Dengan kata lain, meskipun session3 bersamaan telah membuat tabel, session2 tidak melihat tabel karena tidak ada dalam snapshot.
Untuk mengatasi kesalahan ini, Anda dapat menyusun ulang sesi sebagai berikut.
```
session1 = # BEGIN;
session1 = # DROP TABLE A;
session1 = # COMMIT;
```
```
session3 = # BEGIN;
session3 = # CREATE TABLE A (id INT);
session3 = # COMMIT;
```
```
session2 = # BEGIN;
session2 = # SELECT * FROM A;
```
Sekarang ketika session2 mengambil snapshot-nya, session3 telah dilakukan, dan tabelnya ada di database. Session2 dapat membaca dari tabel tanpa kesalahan.
# Tutorial: Memuat data dari Amazon S3
Dalam tutorial ini, Anda berjalan melalui proses memuat data ke dalam tabel database Amazon Redshift Anda dari file data dalam bucket Amazon S3 dari awal hingga akhir.
Dalam tutorial ini, Anda akan melakukan hal-hal berikut:
+ Unduh file data yang menggunakan nilai dipisahkan koma (CSV), dibatasi karakter, dan format lebar tetap.
+ Buat bucket Amazon S3 lalu unggah file data ke bucket.
+ Luncurkan cluster Amazon Redshift dan buat tabel database.
+ Gunakan perintah COPY untuk memuat tabel dari file data di Amazon S3.
+ Memecahkan masalah kesalahan pemuatan dan memodifikasi perintah COPY Anda untuk memperbaiki kesalahan.
## Prasyarat
Anda membutuhkan prasyarat berikut:
+ AWS Akun untuk meluncurkan cluster Amazon Redshift dan membuat ember di Amazon S3.
+ AWS Kredensi Anda (peran IAM) untuk memuat data pengujian dari Amazon S3. Jika Anda membutuhkan peran IAM baru, buka [Membuat peran IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html).
+ Klien SQL seperti editor kueri konsol Amazon Redshift.
Tutorial ini dirancang sedemikian rupa sehingga dapat diambil dengan sendirinya. Selain tutorial ini, kami sarankan untuk menyelesaikan tutorial berikut untuk mendapatkan pemahaman yang lebih lengkap tentang cara merancang dan menggunakan database Amazon Redshift:
+ Panduan [Memulai Amazon Redshift memandu](https://docs.aws.amazon.com/redshift/latest/gsg/) Anda melalui proses pembuatan klaster Amazon Redshift dan memuat data sampel.
## Ikhtisar
Anda dapat menambahkan data ke tabel Amazon Redshift baik dengan menggunakan perintah INSERT atau dengan menggunakan perintah COPY. Pada skala dan kecepatan gudang data Amazon Redshift, perintah COPY berkali-kali lebih cepat dan lebih efisien daripada perintah INSERT.
Perintah COPY menggunakan arsitektur Amazon Redshift massively parallel processing (MPP) untuk membaca dan memuat data secara paralel dari berbagai sumber data. Anda dapat memuat dari file data di Amazon S3, Amazon EMR, atau host jarak jauh apa pun yang dapat diakses melalui koneksi Secure Shell (SSH). Atau Anda dapat memuat langsung dari tabel Amazon DynamoDB.
Dalam tutorial ini, Anda menggunakan perintah COPY untuk memuat data dari Amazon S3. Banyak prinsip yang disajikan di sini berlaku untuk pemuatan dari sumber data lain juga.
Untuk mempelajari lebih lanjut tentang menggunakan perintah COPY, lihat sumber daya ini:
+ [Praktik terbaik Amazon Redshift untuk memuat data](c_loading-data-best-practices.md)
+ [Memuat data dari Amazon EMR](loading-data-from-emr.md)
+ [Memuat data dari host jarak jauh](loading-data-from-remote-hosts.md)
+ [Memuat data dari tabel Amazon DynamoDB](t_Loading-data-from-dynamodb.md)
## Langkah 1: Buat cluster
Jika Anda sudah memiliki cluster yang ingin Anda gunakan, Anda dapat melewati langkah ini.
Untuk latihan dalam tutorial ini, gunakan cluster empat simpul.
**Untuk membuat klaster DB**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon Redshift di. [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)
Menggunakan menu navigasi, pilih dasbor **Cluster yang disediakan**.
**penting**
Pastikan Anda memiliki izin yang diperlukan untuk melakukan operasi cluster. Untuk informasi tentang pemberian izin yang diperlukan, lihat [Mengotorisasi Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) untuk mengakses layanan. AWS
1. Di kanan atas, pilih AWS Wilayah tempat Anda ingin membuat cluster. Untuk keperluan tutorial ini, pilih **US West (Oregon)**.
1. Pada menu navigasi, pilih **Clusters**, lalu pilih **Create cluster**. Halaman **Create cluster** muncul.
1. Pada halaman **Create cluster** masukkan parameter untuk cluster Anda. Pilih nilai Anda sendiri untuk parameter, kecuali ubah nilai berikut:
+ Pilih **dc2.large** untuk jenis node.
+ Pilih **4** untuk **Jumlah node**.
+ Di bagian **izin Cluster**, pilih peran IAM dari peran IAM **yang Tersedia**. Peran ini harus menjadi salah satu yang Anda buat sebelumnya dan yang memiliki akses ke Amazon S3. Kemudian pilih **peran IAM Associate** untuk menambahkannya ke daftar **peran IAM Terkait** untuk cluster.
1. Pilih **Buat klaster**.
Ikuti langkah-langkah [Panduan Memulai Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/) untuk menyambung ke cluster Anda dari klien SQL dan menguji koneksi. Anda tidak perlu menyelesaikan langkah-langkah Memulai yang tersisa untuk membuat tabel, mengunggah data, dan mencoba contoh kueri.
## Langkah 2: Unduh file data
Pada langkah ini, Anda mengunduh satu set file data sampel ke komputer Anda. Pada langkah berikutnya, Anda mengunggah file ke bucket Amazon S3.
**Untuk mengunduh file data**
1. Unduh file zip: [LoadingDataSampleFiles.zip](samples/LoadingDataSampleFiles.zip).
1. Ekstrak file ke folder di komputer Anda.
1. Verifikasi bahwa folder Anda berisi file-file berikut.
```
customer-fw-manifest
customer-fw.tbl-000
customer-fw.tbl-000.bak
customer-fw.tbl-001
customer-fw.tbl-002
customer-fw.tbl-003
customer-fw.tbl-004
customer-fw.tbl-005
customer-fw.tbl-006
customer-fw.tbl-007
customer-fw.tbl.log
dwdate-tab.tbl-000
dwdate-tab.tbl-001
dwdate-tab.tbl-002
dwdate-tab.tbl-003
dwdate-tab.tbl-004
dwdate-tab.tbl-005
dwdate-tab.tbl-006
dwdate-tab.tbl-007
part-csv.tbl-000
part-csv.tbl-001
part-csv.tbl-002
part-csv.tbl-003
part-csv.tbl-004
part-csv.tbl-005
part-csv.tbl-006
part-csv.tbl-007
```
## Langkah 3: Unggah file ke bucket Amazon S3
Pada langkah ini, Anda membuat bucket Amazon S3 dan mengunggah file data ke bucket.
###
**Untuk mengunggah file ke bucket Amazon S3**
1. Buat ember di Amazon S3.
Untuk informasi selengkapnya tentang membuat bucket, lihat [Membuat bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) di *Panduan Pengguna Layanan Penyimpanan Sederhana Amazon*.
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Pilih **Buat bucket**.
1. Pilih sebuah Wilayah AWS.
Buat bucket di Region yang sama dengan cluster Anda. Jika cluster Anda berada di Wilayah AS Barat (Oregon), pilih Wilayah **AS Barat (Oregon) (us-west-2)**.
1. Di kotak **Nama Bucket** pada kotak dialog **Buat ember**, masukkan nama bucket.
Nama bucket yang Anda pilih harus unik di antara semua nama bucket yang ada di Amazon S3. Salah satu cara untuk membantu memastikan keunikan adalah dengan mengawali nama bucket Anda dengan nama organisasi Anda. Nama bucket harus mematuhi aturan tertentu. Untuk informasi selengkapnya, buka [Pembatasan dan batasan Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) di *Panduan Pengguna Layanan Penyimpanan Sederhana Amazon.*
1. Pilih default yang disarankan untuk opsi lainnya.
1. Pilih **Buat bucket**.
Saat Amazon S3 berhasil membuat bucket Anda, konsol akan menampilkan bucket kosong Anda di panel **Bucket**.
1. Buat folder.
1. Pilih nama ember baru.
1. Pilih tombol **Buat Folder**.
1. Beri nama folder baru**load**.
**catatan**
Ember yang Anda buat tidak ada di kotak pasir. Dalam latihan ini, Anda menambahkan objek ke ember sungguhan. Anda dikenakan jumlah nominal untuk waktu Anda menyimpan benda-benda di ember. Untuk informasi lebih lanjut tentang harga Amazon S3, buka halaman harga [Amazon S3](https://aws.amazon.com/s3/pricing/).
1. Unggah file data ke bucket Amazon S3 baru.
1. Pilih nama folder data.
1. Di wizard Unggah, pilih **Tambahkan file**.
Ikuti petunjuk konsol Amazon S3 untuk mengunggah semua file yang Anda unduh dan ekstrak,
1. Pilih **Unggah**.
**Kredensial Pengguna**
Perintah Amazon Redshift COPY harus memiliki akses untuk membaca objek file di bucket Amazon S3. Jika Anda menggunakan kredensi pengguna yang sama untuk membuat bucket Amazon S3 dan menjalankan perintah Amazon Redshift COPY, perintah COPY memiliki semua izin yang diperlukan. Jika Anda ingin menggunakan kredensil pengguna yang berbeda, Anda dapat memberikan akses dengan menggunakan kontrol akses Amazon S3. Perintah Amazon Redshift COPY memerlukan setidaknya ListBucket dan GetObject izin untuk mengakses objek file di bucket Amazon S3. Untuk informasi selengkapnya tentang mengontrol akses ke sumber daya Amazon S3, buka [Mengelola izin akses ke sumber daya Amazon S3 Anda](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html).
## Langkah 4: Buat tabel sampel
Untuk tutorial ini, Anda menggunakan satu set tabel berdasarkan skema Star Schema Benchmark (SSB). Diagram berikut menunjukkan model data SSB.
![\[Lima tabel skema SSB dan hubungannya satu sama lain.\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/images/tutorial-optimize-tables-ssb-data-model.png)
Tabel SSB mungkin sudah ada di database saat ini. Jika demikian, jatuhkan tabel untuk menghapusnya dari database sebelum Anda membuatnya menggunakan perintah CREATE TABLE di langkah berikutnya. Tabel yang digunakan dalam tutorial ini mungkin memiliki atribut yang berbeda dari tabel yang ada.
**Untuk membuat tabel sampel**
1. Untuk menjatuhkan tabel SSB, jalankan perintah berikut di klien SQL Anda.
```
drop table part cascade;
drop table supplier;
drop table customer;
drop table dwdate;
drop table lineorder;
```
1. Jalankan perintah CREATE TABLE berikut di klien SQL Anda.
```
CREATE TABLE part
(
p_partkey INTEGER NOT NULL,
p_name VARCHAR(22) NOT NULL,
p_mfgr VARCHAR(6),
p_category VARCHAR(7) NOT NULL,
p_brand1 VARCHAR(9) NOT NULL,
p_color VARCHAR(11) NOT NULL,
p_type VARCHAR(25) NOT NULL,
p_size INTEGER NOT NULL,
p_container VARCHAR(10) NOT NULL
);
CREATE TABLE supplier
(
s_suppkey INTEGER NOT NULL,
s_name VARCHAR(25) NOT NULL,
s_address VARCHAR(25) NOT NULL,
s_city VARCHAR(10) NOT NULL,
s_nation VARCHAR(15) NOT NULL,
s_region VARCHAR(12) NOT NULL,
s_phone VARCHAR(15) NOT NULL
);
CREATE TABLE customer
(
c_custkey INTEGER NOT NULL,
c_name VARCHAR(25) NOT NULL,
c_address VARCHAR(25) NOT NULL,
c_city VARCHAR(10) NOT NULL,
c_nation VARCHAR(15) NOT NULL,
c_region VARCHAR(12) NOT NULL,
c_phone VARCHAR(15) NOT NULL,
c_mktsegment VARCHAR(10) NOT NULL
);
CREATE TABLE dwdate
(
d_datekey INTEGER NOT NULL,
d_date VARCHAR(19) NOT NULL,
d_dayofweek VARCHAR(10) NOT NULL,
d_month VARCHAR(10) NOT NULL,
d_year INTEGER NOT NULL,
d_yearmonthnum INTEGER NOT NULL,
d_yearmonth VARCHAR(8) NOT NULL,
d_daynuminweek INTEGER NOT NULL,
d_daynuminmonth INTEGER NOT NULL,
d_daynuminyear INTEGER NOT NULL,
d_monthnuminyear INTEGER NOT NULL,
d_weeknuminyear INTEGER NOT NULL,
d_sellingseason VARCHAR(13) NOT NULL,
d_lastdayinweekfl VARCHAR(1) NOT NULL,
d_lastdayinmonthfl VARCHAR(1) NOT NULL,
d_holidayfl VARCHAR(1) NOT NULL,
d_weekdayfl VARCHAR(1) NOT NULL
);
CREATE TABLE lineorder
(
lo_orderkey INTEGER NOT NULL,
lo_linenumber INTEGER NOT NULL,
lo_custkey INTEGER NOT NULL,
lo_partkey INTEGER NOT NULL,
lo_suppkey INTEGER NOT NULL,
lo_orderdate INTEGER NOT NULL,
lo_orderpriority VARCHAR(15) NOT NULL,
lo_shippriority VARCHAR(1) NOT NULL,
lo_quantity INTEGER NOT NULL,
lo_extendedprice INTEGER NOT NULL,
lo_ordertotalprice INTEGER NOT NULL,
lo_discount INTEGER NOT NULL,
lo_revenue INTEGER NOT NULL,
lo_supplycost INTEGER NOT NULL,
lo_tax INTEGER NOT NULL,
lo_commitdate INTEGER NOT NULL,
lo_shipmode VARCHAR(10) NOT NULL
);
```
## Langkah 5: Jalankan perintah COPY
Anda menjalankan perintah COPY untuk memuat setiap tabel dalam skema SSB. Contoh perintah COPY menunjukkan pemuatan dari format file yang berbeda, menggunakan beberapa opsi perintah COPY, dan pemecahan masalah kesalahan pemuatan.
### COPY sintaks perintah
Sintaks [MENYONTEK](r_COPY.md) perintah dasar adalah sebagai berikut.
```
COPY table_name [ column_list ] FROM data_source CREDENTIALS access_credentials [options]
```
Untuk menjalankan perintah COPY, Anda memberikan nilai-nilai berikut.
**Nama tabel**
Tabel target untuk perintah COPY. Tabel harus sudah ada dalam basis data. Tabel bisa bersifat sementara atau persisten. Perintah COPY menambahkan data input baru ke setiap baris yang ada dalam tabel.
**Daftar kolom**
Secara default, COPY memuat bidang dari data sumber ke kolom tabel secara berurutan. Anda dapat secara opsional menentukan *daftar kolom,* yaitu daftar nama kolom yang dipisahkan koma, untuk memetakan bidang data ke kolom tertentu. Anda tidak menggunakan daftar kolom dalam tutorial ini. Untuk informasi selengkapnya, lihat [Column List](copy-parameters-column-mapping.md#copy-column-list) di referensi perintah COPY.
Sumber data
Anda dapat menggunakan perintah COPY untuk memuat data dari bucket Amazon S3, cluster EMR Amazon, host jarak jauh menggunakan koneksi SSH, atau tabel Amazon DynamoDB. Untuk tutorial ini, Anda memuat dari file data di bucket Amazon S3. Saat memuat dari Amazon S3, Anda harus memberikan nama bucket dan lokasi file data. Untuk melakukan ini, berikan jalur objek untuk file data atau lokasi file manifes yang secara eksplisit mencantumkan setiap file data dan lokasinya.
+ Awalan kunci
Objek yang disimpan di Amazon S3 diidentifikasi secara unik oleh kunci objek, yang mencakup nama bucket, nama folder, jika ada, dan nama objek. Sebuah *key prefix* mengacu pada satu set objek dengan awalan yang sama. Object path adalah key prefix yang digunakan perintah COPY untuk memuat semua objek yang berbagi key prefix. Misalnya, key prefix `custdata.txt` dapat merujuk ke satu file atau ke satu set file, termasuk, `custdata.txt.001``custdata.txt.002`, dan sebagainya.
+ Berkas manifes
Dalam beberapa kasus, Anda mungkin perlu memuat file dengan awalan yang berbeda, misalnya dari beberapa bucket atau folder. Di tempat lain, Anda mungkin perlu mengecualikan file yang berbagi awalan. Dalam kasus ini, Anda dapat menggunakan file manifes. *File manifes* secara eksplisit mencantumkan setiap file pemuatan dan kunci objek uniknya. Anda menggunakan file manifes untuk memuat tabel PART nanti dalam tutorial ini.
**Kredensial**
Untuk mengakses AWS sumber daya yang berisi data yang akan dimuat, Anda harus memberikan kredensi AWS akses bagi pengguna dengan hak istimewa yang memadai. Kredensi ini mencakup peran IAM Amazon Resource Name (ARN). Untuk memuat data dari Amazon S3, kredensi harus menyertakan dan izin. ListBucket GetObject Kredensi tambahan diperlukan jika data Anda dienkripsi. Untuk informasi selengkapnya, lihat [Parameter otorisasi](copy-parameters-authorization.md) di referensi perintah COPY. Untuk informasi selengkapnya tentang mengelola akses, buka [Mengelola izin akses ke sumber daya Amazon S3 Anda](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html).
Pilihan
Anda dapat menentukan sejumlah parameter dengan perintah COPY untuk menentukan format file, mengelola format data, mengelola kesalahan, dan mengontrol fitur lainnya. Dalam tutorial ini, Anda menggunakan opsi dan fitur perintah COPY berikut:
+ Awalan kunci
Untuk informasi tentang cara memuat dari beberapa file dengan menentukan key prefix, lihat. [Muat tabel PART menggunakan NULL AS](#tutorial-loading-load-part)
+ Format CSV
Untuk informasi tentang cara memuat data dalam format CSV, lihat[Muat tabel PART menggunakan NULL AS](#tutorial-loading-load-part).
+ NULL SEBAGAI
Untuk informasi tentang cara memuat PART menggunakan opsi NULL AS, lihat[Muat tabel PART menggunakan NULL AS](#tutorial-loading-load-part).
+ Format yang dibatasi karakter
Untuk informasi tentang cara menggunakan opsi DELIMITER, lihat. [Opsi DELIMITER dan REGION](#tutorial-loading-load-supplier)
+ DAERAH
Untuk informasi tentang cara menggunakan opsi REGION, lihat[Opsi DELIMITER dan REGION](#tutorial-loading-load-supplier).
+ Lebar format tetap
Untuk informasi tentang cara memuat tabel PELANGGAN dari data dengan lebar tetap, lihat. [Muat tabel PELANGGAN menggunakan MANIFEST](#tutorial-loading-load-customer)
+ MAXERROR
Untuk informasi tentang cara menggunakan opsi MAXERROR, lihat[Muat tabel PELANGGAN menggunakan MANIFEST](#tutorial-loading-load-customer).
+ MENERIMAINVCHARS
Untuk informasi tentang cara menggunakan opsi ACCEPTINVCHARS, lihat. [Muat tabel PELANGGAN menggunakan MANIFEST](#tutorial-loading-load-customer)
+ NYATA
Untuk informasi tentang cara menggunakan opsi MANIFEST, lihat[Muat tabel PELANGGAN menggunakan MANIFEST](#tutorial-loading-load-customer).
+ FORMAT TANGGAL
Untuk informasi tentang cara menggunakan opsi DATEFORMAT, lihat. [Muat tabel DWDATE menggunakan DATEFORMAT](#tutorial-loading-load-dwdate)
+ GZIP, LZOP dan BZIP2
Untuk informasi tentang cara mengompres file Anda, lihat[Memuat beberapa file data](#tutorial-loading-load-lineorder).
+ KOMPUPDATE
Untuk informasi tentang cara menggunakan opsi COMPUPDATE, lihat. [Memuat beberapa file data](#tutorial-loading-load-lineorder)
+ Beberapa file
Untuk informasi tentang cara memuat banyak file, lihat[Memuat beberapa file data](#tutorial-loading-load-lineorder).
### Memuat tabel SSB
Anda menggunakan perintah COPY berikut untuk memuat setiap tabel dalam skema SSB. Perintah untuk setiap tabel menunjukkan opsi COPY dan teknik pemecahan masalah yang berbeda.
Untuk memuat tabel SSB, ikuti langkah-langkah ini:
1. [Ganti nama bucket dan AWS kredensialnya](#tutorial-loading-run-copy-replaceables)
1. [Muat tabel PART menggunakan NULL AS](#tutorial-loading-load-part)
1. [Muat tabel PELANGGAN menggunakan MANIFEST](#tutorial-loading-load-customer)
1. [Muat tabel DWDATE menggunakan DATEFORMAT](#tutorial-loading-load-dwdate)
#### Ganti nama bucket dan AWS kredensialnya
Perintah COPY dalam tutorial ini disajikan dalam format berikut.
```
copy table from 's3:///load/key_prefix'
credentials 'aws_iam_role=arn:aws:iam:::role/'
options;
```
Untuk setiap perintah COPY, lakukan hal berikut:
1. Ganti ** dengan nama bucket di wilayah yang sama dengan cluster Anda.
Langkah ini mengasumsikan bucket dan cluster berada di wilayah yang sama. Atau, Anda dapat menentukan wilayah menggunakan [REGION](copy-parameters-data-source-s3.md#copy-region) opsi dengan perintah COPY.
1. Ganti ** dan ** dengan peran Anda sendiri Akun AWS dan IAM. Segmen string kredensial yang diapit tanda kutip tunggal tidak boleh berisi spasi atau jeda baris. Perhatikan bahwa ARN mungkin sedikit berbeda dalam format dari sampel. Yang terbaik adalah menyalin ARN untuk peran dari konsol IAM, untuk memastikan bahwa itu akurat, ketika Anda menjalankan perintah COPY.
#### Muat tabel PART menggunakan NULL AS
Pada langkah ini, Anda menggunakan opsi CSV dan NULL AS untuk memuat tabel PART.
Perintah COPY dapat memuat data dari beberapa file secara paralel, yang jauh lebih cepat daripada memuat dari satu file. Untuk menunjukkan prinsip ini, data untuk setiap tabel dalam tutorial ini dibagi menjadi delapan file, meskipun file sangat kecil. Pada langkah selanjutnya, Anda membandingkan perbedaan waktu antara memuat dari satu file dan memuat dari beberapa file. Untuk informasi selengkapnya, lihat [Memuat file data](c_best-practices-use-multiple-files.md).
**Awalan kunci**
Anda dapat memuat dari beberapa file dengan menentukan key prefix untuk kumpulan file, atau dengan secara eksplisit mencantumkan file dalam file manifes. Pada langkah ini, Anda menggunakan key prefix. Pada langkah selanjutnya, Anda menggunakan file manifes. Prefix key `'s3://amzn-s3-demo-bucket/load/part-csv.tbl'` memuat kumpulan file berikut dalam folder. `load`
```
part-csv.tbl-000
part-csv.tbl-001
part-csv.tbl-002
part-csv.tbl-003
part-csv.tbl-004
part-csv.tbl-005
part-csv.tbl-006
part-csv.tbl-007
```
**Format CSV**
CSV, yang merupakan singkatan dari nilai dipisahkan koma, adalah format umum yang digunakan untuk mengimpor dan mengekspor data spreadsheet. CSV lebih fleksibel daripada format yang dibatasi koma karena memungkinkan Anda untuk memasukkan string yang dikutip dalam bidang. Karakter tanda kutip default untuk COPY dari format CSV adalah tanda kutip ganda ("), tetapi Anda dapat menentukan karakter tanda kutip lain dengan menggunakan opsi QUOTE AS. Saat Anda menggunakan karakter tanda kutip di dalam bidang, lepaskan karakter dengan karakter tanda kutip tambahan.
Kutipan berikut dari file data berformat CSV untuk tabel PART menunjukkan string terlampir dalam tanda kutip ganda (). `"LARGE ANODIZED BRASS"` Ini juga menunjukkan string tertutup dalam dua tanda kutip ganda dalam string yang dikutip (). `"MEDIUM ""BURNISHED"" TIN"`
```
15,dark sky,MFGR#3,MFGR#47,MFGR#3438,indigo,"LARGE ANODIZED BRASS",45,LG CASE
22,floral beige,MFGR#4,MFGR#44,MFGR#4421,medium,"PROMO, POLISHED BRASS",19,LG DRUM
23,bisque slate,MFGR#4,MFGR#41,MFGR#4137,firebrick,"MEDIUM ""BURNISHED"" TIN",42,JUMBO JAR
```
Data untuk tabel PART berisi karakter yang menyebabkan COPY gagal. Dalam latihan ini, Anda memecahkan masalah kesalahan dan memperbaikinya.
Untuk memuat data yang dalam format CSV, tambahkan `csv` ke perintah COPY Anda. Jalankan perintah berikut untuk memuat tabel PART.
```
copy part from 's3:///load/part-csv.tbl'
credentials 'aws_iam_role=arn:aws:iam:::role/'
csv;
```
Anda mungkin mendapatkan pesan kesalahan yang mirip dengan berikut ini.
```
An error occurred when executing the SQL command:
copy part from 's3://amzn-s3-demo-bucket/load/part-csv.tbl'
credentials' ...
ERROR: Load into table 'part' failed. Check 'stl_load_errors' system table for details. [SQL State=XX000]
Execution time: 1.46s
1 statement(s) failed.
1 statement(s) failed.
```
Untuk mendapatkan informasi lebih lanjut tentang kesalahan, kueri tabel STL\$1LOAD\$1ERRORS. Kueri berikut menggunakan fungsi SUBSTRING untuk mempersingkat kolom agar mudah dibaca dan menggunakan LIMIT 10 untuk mengurangi jumlah baris yang dikembalikan. Anda dapat menyesuaikan nilai `substring(filename,22,25)` untuk memungkinkan panjang nama bucket Anda.
```
select query, substring(filename,22,25) as filename,line_number as line,
substring(colname,0,12) as column, type, position as pos, substring(raw_line,0,30) as line_text,
substring(raw_field_value,0,15) as field_text,
substring(err_reason,0,45) as reason
from stl_load_errors
order by query desc
limit 10;
```
```
query | filename | line | column | type | pos |
--------+-------------------------+-----------+------------+------------+-----+----
333765 | part-csv.tbl-000 | 1 | | | 0 |
line_text | field_text | reason
------------------+------------+----------------------------------------------
15,NUL next, | | Missing newline: Unexpected character 0x2c f
```
**NULL SEBAGAI**
File `part-csv.tbl` data menggunakan karakter terminator NUL (`\x000`atau`\x0`) untuk menunjukkan nilai NULL.
**catatan**
Meskipun ejaan yang sangat mirip, NUL dan NULL tidak sama. NUL adalah karakter UTF-8 dengan codepoint `x000` yang sering digunakan untuk menunjukkan akhir catatan (EOR). NULL adalah nilai SQL yang mewakili tidak adanya data.
Secara default, COPY memperlakukan karakter terminator NUL sebagai karakter EOR dan mengakhiri rekaman, yang sering menghasilkan hasil yang tidak terduga atau kesalahan. Tidak ada metode standar tunggal untuk menunjukkan NULL dalam data teks. Dengan demikian, opsi perintah NULL AS COPY memungkinkan Anda menentukan karakter mana yang akan diganti dengan NULL saat memuat tabel. Dalam contoh ini, Anda ingin COPY memperlakukan karakter terminator NUL sebagai nilai NULL.
**catatan**
Kolom tabel yang menerima nilai NULL harus dikonfigurasi sebagai *nullable*. Artinya, itu tidak boleh menyertakan kendala NOT NULL dalam spesifikasi CREATE TABLE.
Untuk memuat BAGIAN menggunakan opsi NULL AS, jalankan perintah COPY berikut.
```
copy part from 's3:///load/part-csv.tbl'
credentials 'aws_iam_role=arn:aws:iam:::role/'
csv
null as '\000';
```
Untuk memverifikasi bahwa COPY memuat nilai NULL, jalankan perintah berikut untuk memilih hanya baris yang berisi NULL.
```
select p_partkey, p_name, p_mfgr, p_category from part where p_mfgr is null;
```
```
p_partkey | p_name | p_mfgr | p_category
-----------+----------+--------+------------
15 | NUL next | | MFGR#47
81 | NUL next | | MFGR#23
133 | NUL next | | MFGR#44
(2 rows)
```
#### Opsi DELIMITER dan REGION
Opsi DELIMITER dan REGION penting untuk memahami cara memuat data.
**Format yang dibatasi karakter**
Bidang dalam file yang dibatasi karakter dipisahkan oleh karakter tertentu, seperti karakter pipa (\$1), koma (,) atau tab (\$1 t). File yang dibatasi karakter dapat menggunakan karakter ASCII tunggal apa pun, termasuk salah satu karakter ASCII yang tidak dicetak, sebagai pembatas. Anda menentukan karakter pembatas dengan menggunakan opsi DELIMITER. Pembatas default adalah karakter pipa (\$1).
Kutipan berikut dari data untuk tabel SUPPLIER menggunakan format yang dibatasi pipa.
```
1|1|257368|465569|41365|19950218|2-HIGH|0|17|2608718|9783671|4|2504369|92072|2|19950331|TRUCK
1|2|257368|201928|8146|19950218|2-HIGH|0|36|6587676|9783671|9|5994785|109794|6|19950416|MAIL
```
**DAERAH**
Jika memungkinkan, Anda harus menemukan data pemuatan Anda di AWS wilayah yang sama dengan cluster Amazon Redshift Anda. Jika data dan cluster Anda berada di wilayah yang sama, Anda mengurangi latensi dan menghindari biaya transfer data lintas wilayah. Untuk informasi selengkapnya, lihat [Praktik terbaik Amazon Redshift untuk memuat data](c_loading-data-best-practices.md).
Jika Anda harus memuat data dari AWS wilayah yang berbeda, gunakan opsi REGION untuk menentukan AWS wilayah di mana data beban berada. Jika Anda menentukan wilayah, semua data pemuatan, termasuk file manifes, harus berada di wilayah bernama. Untuk informasi selengkapnya, lihat [REGION](copy-parameters-data-source-s3.md#copy-region).
Misalnya, jika klaster Anda berada di Wilayah AS Timur (Virginia N.), dan bucket Amazon S3 Anda terletak di Wilayah AS Barat (Oregon), perintah COPY berikut menunjukkan cara memuat tabel SUPPLIER dari data yang dibatasi pipa.
```
copy supplier from 's3://amzn-s3-demo-bucket/ssb/supplier.tbl'
credentials 'aws_iam_role=arn:aws:iam:::role/'
delimiter '|'
gzip
region 'us-west-2';
```
#### Muat tabel PELANGGAN menggunakan MANIFEST
Pada langkah ini, Anda menggunakan opsi FIXEDWIDTH, MAXERROR, ACCEPTINVCHARS, dan MANIFEST untuk memuat tabel PELANGGAN.
Data sampel untuk latihan ini berisi karakter yang menyebabkan kesalahan saat COPY mencoba memuatnya. Anda menggunakan opsi MAXERRORS dan tabel sistem STL\$1LOAD\$1ERRORS untuk memecahkan masalah kesalahan pemuatan dan kemudian menggunakan opsi ACCEPTINVCHARS dan MANIFEST untuk menghilangkan kesalahan.
**Format Lebar Tetap**
Format Fixed-width mendefinisikan setiap bidang sebagai jumlah karakter tetap, bukan memisahkan bidang dengan pembatas. Kutipan berikut dari data untuk tabel PELANGGAN menggunakan format lebar tetap.
```
1 Customer#000000001 IVhzIApeRb MOROCCO 0MOROCCO AFRICA 25-705
2 Customer#000000002 XSTf4,NCwDVaWNe6tE JORDAN 6JORDAN MIDDLE EAST 23-453
3 Customer#000000003 MG9kdTD ARGENTINA5ARGENTINAAMERICA 11-783
```
Urutan label/width pasangan harus sesuai dengan urutan kolom tabel dengan tepat. Untuk informasi selengkapnya, lihat [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth).
String spesifikasi lebar tetap untuk data tabel PELANGGAN adalah sebagai berikut.
```
fixedwidth 'c_custkey:10, c_name:25, c_address:25, c_city:10, c_nation:15,
c_region :12, c_phone:15,c_mktsegment:10'
```
Untuk memuat tabel CUSTOMER dari data fixed-width, jalankan perintah berikut.
```
copy customer
from 's3:///load/customer-fw.tbl'
credentials 'aws_iam_role=arn:aws:iam:::role/'
fixedwidth 'c_custkey:10, c_name:25, c_address:25, c_city:10, c_nation:15, c_region :12, c_phone:15,c_mktsegment:10';
```
Anda harus mendapatkan pesan kesalahan, mirip dengan yang berikut ini.
```
An error occurred when executing the SQL command:
copy customer
from 's3://amzn-s3-demo-bucket/load/customer-fw.tbl'
credentials'...
ERROR: Load into table 'customer' failed. Check 'stl_load_errors' system table for details. [SQL State=XX000]
Execution time: 2.95s
1 statement(s) failed.
```
**MAXERROR**
Secara default, pertama kali COPY menemukan kesalahan, perintah gagal dan mengembalikan pesan kesalahan. Untuk menghemat waktu selama pengujian, Anda dapat menggunakan opsi MAXERROR untuk menginstruksikan COPY untuk melewati sejumlah kesalahan tertentu sebelum gagal. Karena kami mengharapkan kesalahan saat pertama kali kami menguji pemuatan data tabel PELANGGAN, tambahkan `maxerror 10` ke perintah COPY.
Untuk menguji menggunakan opsi FIXEDWIDTH dan MAXERROR, jalankan perintah berikut.
```
copy customer
from 's3:///load/customer-fw.tbl'
credentials 'aws_iam_role=arn:aws:iam:::role/'
fixedwidth 'c_custkey:10, c_name:25, c_address:25, c_city:10, c_nation:15, c_region :12, c_phone:15,c_mktsegment:10'
maxerror 10;
```
Kali ini, alih-alih pesan kesalahan, Anda mendapatkan pesan peringatan yang mirip dengan yang berikut ini.
```
Warnings:
Load into table 'customer' completed, 112497 record(s) loaded successfully.
Load into table 'customer' completed, 7 record(s) could not be loaded. Check 'stl_load_errors' system table for details.
```
Peringatan menunjukkan bahwa COPY mengalami tujuh kesalahan. Untuk memeriksa kesalahan, kueri tabel STL\$1LOAD\$1ERRORS, seperti yang ditunjukkan pada contoh berikut.
```
select query, substring(filename,22,25) as filename,line_number as line,
substring(colname,0,12) as column, type, position as pos, substring(raw_line,0,30) as line_text,
substring(raw_field_value,0,15) as field_text,
substring(err_reason,0,45) as error_reason
from stl_load_errors
order by query desc, filename
limit 7;
```
Hasil kueri STL\$1LOAD\$1ERRORS akan terlihat mirip dengan yang berikut ini.
```
query | filename | line | column | type | pos | line_text | field_text | error_reason
--------+---------------------------+------+-----------+------------+-----+-------------------------------+------------+----------------------------------------------
334489 | customer-fw.tbl.log | 2 | c_custkey | int4 | -1 | customer-fw.tbl | customer-f | Invalid digit, Value 'c', Pos 0, Type: Integ
334489 | customer-fw.tbl.log | 6 | c_custkey | int4 | -1 | Complete | Complete | Invalid digit, Value 'C', Pos 0, Type: Integ
334489 | customer-fw.tbl.log | 3 | c_custkey | int4 | -1 | #Total rows | #Total row | Invalid digit, Value '#', Pos 0, Type: Integ
334489 | customer-fw.tbl.log | 5 | c_custkey | int4 | -1 | #Status | #Status | Invalid digit, Value '#', Pos 0, Type: Integ
334489 | customer-fw.tbl.log | 1 | c_custkey | int4 | -1 | #Load file | #Load file | Invalid digit, Value '#', Pos 0, Type: Integ
334489 | customer-fw.tbl000 | 1 | c_address | varchar | 34 | 1 Customer#000000001 | .Mayag.ezR | String contains invalid or unsupported UTF8
334489 | customer-fw.tbl000 | 1 | c_address | varchar | 34 | 1 Customer#000000001 | .Mayag.ezR | String contains invalid or unsupported UTF8
(7 rows)
```
Dengan memeriksa hasilnya, Anda dapat melihat bahwa ada dua pesan di `error_reasons` kolom:
+
```
Invalid digit, Value '#', Pos 0, Type: Integ
```
Kesalahan ini disebabkan oleh `customer-fw.tbl.log` file. Masalahnya adalah itu adalah file log, bukan file data, dan tidak boleh dimuat. Anda dapat menggunakan file manifes untuk menghindari memuat file yang salah.
+
```
String contains invalid or unsupported UTF8
```
Tipe data VARCHAR mendukung multibyte UTF-8 karakter hingga tiga byte. Jika data pemuatan berisi karakter yang tidak didukung atau tidak valid, Anda dapat menggunakan opsi ACCEPTINVCHARS untuk mengganti setiap karakter yang tidak valid dengan karakter alternatif tertentu.
Masalah lain dengan beban lebih sulit dideteksi — beban menghasilkan hasil yang tidak terduga. Untuk menyelidiki masalah ini, jalankan perintah berikut untuk query tabel CUSTOMER.
```
select c_custkey, c_name, c_address
from customer
order by c_custkey
limit 10;
```
```
c_custkey | c_name | c_address
-----------+---------------------------+---------------------------
2 | Customer#000000002 | XSTf4,NCwDVaWNe6tE
2 | Customer#000000002 | XSTf4,NCwDVaWNe6tE
3 | Customer#000000003 | MG9kdTD
3 | Customer#000000003 | MG9kdTD
4 | Customer#000000004 | XxVSJsL
4 | Customer#000000004 | XxVSJsL
5 | Customer#000000005 | KvpyuHCplrB84WgAi
5 | Customer#000000005 | KvpyuHCplrB84WgAi
6 | Customer#000000006 | sKZz0CsnMD7mp4Xd0YrBvx
6 | Customer#000000006 | sKZz0CsnMD7mp4Xd0YrBvx
(10 rows)
```
Baris harus unik, tetapi ada duplikat.
Cara lain untuk memeriksa hasil yang tidak terduga adalah dengan memverifikasi jumlah baris yang dimuat. Dalam kasus kami, 100000 baris seharusnya dimuat, tetapi pesan pemuatan melaporkan memuat 112497 catatan. Baris tambahan dimuat karena COPY memuat file asing,. `customer-fw.tbl0000.bak`
Dalam latihan ini, Anda menggunakan file manifes untuk menghindari memuat file yang salah.
**MENERIMAINVCHARS**
Secara default, ketika COPY menemukan karakter yang tidak didukung oleh tipe data kolom, ia melewatkan baris dan mengembalikan kesalahan. Untuk informasi tentang karakter UTF-8 yang tidak valid, lihat. [Kesalahan pemuatan karakter multibyte](multi-byte-character-load-errors.md)
Anda dapat menggunakan opsi MAXERRORS untuk mengabaikan kesalahan dan melanjutkan pemuatan, lalu kueri STL\$1LOAD\$1ERRORS untuk menemukan karakter yang tidak valid, dan kemudian memperbaiki file data. Namun, MAXERRORS paling baik digunakan untuk memecahkan masalah beban dan umumnya tidak boleh digunakan dalam lingkungan produksi.
Opsi ACCEPTINVCHARS biasanya merupakan pilihan yang lebih baik untuk mengelola karakter yang tidak valid. ACCEPTINVCHARS menginstruksikan COPY untuk mengganti setiap karakter yang tidak valid dengan karakter valid yang ditentukan dan melanjutkan operasi pemuatan. Anda dapat menentukan karakter ASCII yang valid, kecuali NULL, sebagai karakter pengganti. Karakter pengganti default adalah tanda tanya (? ). COPY menggantikan karakter multibyte dengan string pengganti dengan panjang yang sama. Misalnya, karakter 4-byte akan diganti dengan`'????'`.
COPY mengembalikan jumlah baris yang berisi karakter UTF-8 yang tidak valid. Ini juga menambahkan entri ke tabel sistem STL\$1REPLACEMENTS untuk setiap baris yang terpengaruh, hingga maksimum 100 baris per irisan node. Karakter UTF-8 tambahan yang tidak valid juga diganti, tetapi peristiwa pengganti tersebut tidak direkam.
ACCEPTINVCHARS hanya berlaku untuk kolom VARCHAR.
Untuk langkah ini, Anda menambahkan ACCEPTINVCHARS dengan karakter pengganti. `'^'`
**NYATA**
Saat Anda MENYALIN dari Amazon S3 menggunakan key prefix, ada risiko Anda mungkin memuat tabel yang tidak diinginkan. Misalnya, `'s3://amzn-s3-demo-bucket/load/` folder berisi delapan file data yang berbagi key prefix`customer-fw.tbl`:`customer-fw.tbl0000`,`customer-fw.tbl0001`, dan seterusnya. Namun, folder yang sama juga berisi file `customer-fw.tbl.log` asing dan. `customer-fw.tbl-0001.bak`
Untuk memastikan bahwa Anda memuat semua file yang benar, dan hanya file yang benar, gunakan file manifes. Manifes adalah file teks dalam format JSON yang secara eksplisit mencantumkan kunci objek unik untuk setiap file sumber yang akan dimuat. Objek file dapat berada di folder yang berbeda atau ember yang berbeda, tetapi mereka harus berada di wilayah yang sama. Untuk informasi selengkapnya, lihat [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest).
Berikut ini menunjukkan `customer-fw-manifest` teks.
```
{
"entries": [
{"url":"s3:///load/customer-fw.tbl-000"},
{"url":"s3:///load/customer-fw.tbl-001"},
{"url":"s3:///load/customer-fw.tbl-002"},
{"url":"s3:///load/customer-fw.tbl-003"},
{"url":"s3:///load/customer-fw.tbl-004"},
{"url":"s3:///load/customer-fw.tbl-005"},
{"url":"s3:///load/customer-fw.tbl-006"},
{"url":"s3:///load/customer-fw.tbl-007"}
]
}
```
**Untuk memuat data untuk tabel CUSTOMER menggunakan file manifes**
1. Buka file `customer-fw-manifest` di editor teks.
1. Ganti ** dengan nama bucket Anda.
1. Simpan file tersebut.
1. Unggah file ke folder pemuatan di bucket Anda.
1. Jalankan perintah COPY berikut.
```
copy customer from 's3:///load/customer-fw-manifest'
credentials 'aws_iam_role=arn:aws:iam:::role/'
fixedwidth 'c_custkey:10, c_name:25, c_address:25, c_city:10, c_nation:15, c_region :12, c_phone:15,c_mktsegment:10'
maxerror 10
acceptinvchars as '^'
manifest;
```
#### Muat tabel DWDATE menggunakan DATEFORMAT
Pada langkah ini, Anda menggunakan opsi DELIMITER dan DATEFORMAT untuk memuat tabel DWDATE.
Saat memuat kolom DATE dan TIMESTAMP, COPY mengharapkan format default, yaitu YYYY-MM-DD untuk tanggal dan YYYY-MM-DD HH:MI: SS untuk stempel waktu. Jika data beban tidak menggunakan format default, Anda dapat menggunakan DATEFORMAT dan TIMEFORMAT untuk menentukan format.
Kutipan berikut menunjukkan format tanggal dalam tabel DWDATE. Perhatikan bahwa format tanggal di kolom dua tidak konsisten.
```
19920104 1992-01-04 Sunday January 1992 199201 Jan1992 1 4 4 1...
19920112 January 12, 1992 Monday January 1992 199201 Jan1992 2 12 12 1...
19920120 January 20, 1992 Tuesday January 1992 199201 Jan1992 3 20 20 1...
```
**FORMAT TANGGAL**
Anda hanya dapat menentukan satu format tanggal. Jika data pemuatan berisi format yang tidak konsisten, mungkin dalam kolom yang berbeda, atau jika format tidak diketahui pada waktu muat, Anda menggunakan DATEFORMAT dengan argumen. `'auto'` Kapan `'auto'` ditentukan, COPY mengenali format tanggal atau waktu yang valid dan mengubahnya menjadi format default. `'auto'`Opsi ini mengenali beberapa format yang tidak didukung saat menggunakan string DATEFORMAT dan TIMEFORMAT. Untuk informasi selengkapnya, lihat [Menggunakan pengenalan otomatis dengan DATEFORMAT dan TIMEFORMAT](automatic-recognition.md).
Untuk memuat tabel DWDATE, jalankan perintah COPY berikut.
```
copy dwdate from 's3:///load/dwdate-tab.tbl'
credentials 'aws_iam_role=arn:aws:iam:::role/'
delimiter '\t'
dateformat 'auto';
```
#### Memuat beberapa file data
Anda dapat menggunakan opsi GZIP dan COMPUPDATE untuk memuat tabel.
Anda dapat memuat tabel dari satu file data atau beberapa file. Lakukan ini untuk membandingkan waktu muat untuk kedua metode.
**GZIP, LZOP dan BZIP2**
Anda dapat mengompres file Anda menggunakan format kompresi gzip, lzop, atau bzip2. Saat memuat dari file terkompresi, COPY membuka kompres file selama proses pemuatan. Mengompresi file Anda menghemat ruang penyimpanan dan mempersingkat waktu upload.
**KOMPUPDATE**
Ketika COPY memuat tabel kosong tanpa pengkodean kompresi, ia menganalisis data beban untuk menentukan pengkodean yang optimal. Kemudian mengubah tabel untuk menggunakan pengkodean tersebut sebelum memulai beban. Proses analisis ini membutuhkan waktu, tetapi terjadi, paling banyak, sekali per tabel. Untuk menghemat waktu, Anda dapat melewati langkah ini dengan mematikan COMPUPDATE. Untuk mengaktifkan evaluasi waktu COPY yang akurat, Anda menonaktifkan COMPUPDATE untuk langkah ini.
**Beberapa File**
Perintah COPY dapat memuat data dengan sangat efisien ketika memuat dari beberapa file secara paralel, bukan dari satu file. Anda dapat membagi data Anda menjadi file sehingga jumlah file adalah kelipatan dari jumlah irisan di cluster Anda. Jika ya, Amazon Redshift membagi beban kerja dan mendistribusikan data secara merata di antara irisan. Jumlah irisan per node tergantung pada ukuran node cluster. Untuk informasi selengkapnya tentang jumlah irisan yang dimiliki setiap ukuran node, lihat [Tentang cluster dan node di Panduan](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html#rs-about-clusters-and-nodes) Manajemen *Pergeseran Merah Amazon*.
Misalnya, node komputasi di cluster Anda dalam tutorial ini dapat memiliki dua irisan masing-masing, sehingga cluster empat simpul memiliki delapan irisan. Pada langkah sebelumnya, data pemuatan terkandung dalam delapan file, meskipun file-file tersebut sangat kecil. Anda dapat membandingkan perbedaan waktu antara memuat dari satu file besar dan memuat dari beberapa file.
Bahkan file yang berisi 15 juta catatan dan menempati sekitar 1,2 GB sangat kecil dalam skala Amazon Redshift. Tetapi mereka cukup untuk menunjukkan keuntungan kinerja pemuatan dari banyak file.
Gambar berikut menunjukkan file data untuk LINEORDER.
![\[Data dalam tabel LINEORDER dibagi menjadi sembilan file.\]](http://docs.aws.amazon.com/id_id/redshift/latest/dg/images/tutorial-load-lineorder-files.png)
**Untuk mengevaluasi kinerja COPY dengan banyak file**
1. Dalam uji lab, perintah berikut dijalankan ke COPY dari satu file. Perintah ini menunjukkan ember fiktif.
```
copy lineorder from 's3://amzn-s3-demo-bucket/load/lo/lineorder-single.tbl'
credentials 'aws_iam_role=arn:aws:iam:::role/'
gzip
compupdate off
region 'us-east-1';
```
1. Hasilnya adalah sebagai berikut. Perhatikan waktu eksekusi.
```
Warnings:
Load into table 'lineorder' completed, 14996734 record(s) loaded successfully.
0 row(s) affected.
copy executed successfully
Execution time: 51.56s
```
1. Kemudian perintah berikut untuk COPY dari beberapa file dijalankan.
```
copy lineorder from 's3://amzn-s3-demo-bucket/load/lo/lineorder-multi.tbl'
credentials 'aws_iam_role=arn:aws:iam:::role/'
gzip
compupdate off
region 'us-east-1';
```
1. Hasilnya adalah sebagai berikut. Perhatikan waktu eksekusi.
```
Warnings:
Load into table 'lineorder' completed, 14996734 record(s) loaded successfully.
0 row(s) affected.
copy executed successfully
Execution time: 17.7s
```
1. Bandingkan waktu eksekusi.
Dalam percobaan kami, waktu untuk memuat 15 juta catatan menurun dari 51,56 detik menjadi 17,7 detik, pengurangan 65,7 persen.
Hasil ini didasarkan pada penggunaan cluster empat simpul. Jika cluster Anda memiliki lebih banyak node, penghematan waktu dikalikan. Untuk cluster Amazon Redshift yang khas, dengan puluhan hingga ratusan node, perbedaannya bahkan lebih dramatis. Jika Anda memiliki cluster node tunggal, ada sedikit perbedaan antara waktu eksekusi.
## Langkah 6: Vakum dan analisis database
Setiap kali Anda menambahkan, menghapus, atau memodifikasi sejumlah besar baris, Anda harus menjalankan perintah VACUUM dan kemudian perintah ANALYZE. *Vakum* memulihkan ruang dari baris yang dihapus dan mengembalikan urutan pengurutan. Perintah ANALYZE memperbarui metadata statistik, yang memungkinkan pengoptimal kueri menghasilkan rencana kueri yang lebih akurat. Untuk informasi selengkapnya, lihat [Tabel penyedot debu](t_Reclaiming_storage_space202.md).
Jika Anda memuat data dalam urutan kunci sortir, ruang hampa cepat. Dalam tutorial ini, Anda menambahkan sejumlah besar baris, tetapi Anda menambahkannya ke tabel kosong. Karena itu, tidak perlu menggunakan, dan Anda tidak menghapus baris apa pun. COPY secara otomatis memperbarui statistik setelah memuat tabel kosong, jadi statistik Anda seharusnya up-to-date. Namun, sebagai masalah tata graha yang baik, Anda menyelesaikan tutorial ini dengan menyedot debu dan menganalisis database Anda.
Untuk menyedot debu dan menganalisis database, jalankan perintah berikut.
```
vacuum;
analyze;
```
## Langkah 7: Bersihkan sumber daya Anda
Cluster Anda terus bertambah biaya selama itu berjalan. Ketika Anda telah menyelesaikan tutorial ini, Anda harus mengembalikan lingkungan Anda ke keadaan sebelumnya dengan mengikuti langkah-langkah di [Langkah 5: Cabut akses dan hapus cluster sampel Anda di Panduan](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-clean-up-tasks.html) Memulai *Amazon Redshift*.
Jika Anda ingin menyimpan cluster, tetapi memulihkan penyimpanan yang digunakan oleh tabel SSB, jalankan perintah berikut.
```
drop table part;
drop table supplier;
drop table customer;
drop table dwdate;
drop table lineorder;
```
### Selanjutnya
[Ringkasan](#tutorial-loading-data-summary)
## Ringkasan
Dalam tutorial ini, Anda mengunggah file data ke Amazon S3 dan kemudian menggunakan perintah COPY untuk memuat data dari file ke tabel Amazon Redshift.
Anda memuat data menggunakan format berikut:
+ Karakter-dibatasi
+ CSV
+ Lebar tetap
Anda menggunakan tabel sistem STL\$1LOAD\$1ERRORS untuk memecahkan masalah kesalahan pemuatan, lalu menggunakan opsi REGION, MANIFEST, MAXERROR, ACCEPTINVCHARS, DATEFORMAT, dan NULL AS untuk mengatasi kesalahan.
Anda menerapkan praktik terbaik berikut untuk memuat data:
+ [Gunakan perintah COPY untuk memuat data](c_best-practices-use-copy.md)
+ [Memuat file data](c_best-practices-use-multiple-files.md)
+ [Gunakan satu perintah COPY untuk memuat dari beberapa file](c_best-practices-single-copy-command.md)
+ [Mengompresi file data Anda](c_best-practices-compress-data-files.md)
+ [Verifikasi file data sebelum dan sesudah pemuatan](c_best-practices-verifying-data-files.md)
Untuk informasi selengkapnya tentang praktik terbaik Amazon Redshift, lihat tautan berikut:
+ [Praktik terbaik Amazon Redshift untuk memuat data](c_loading-data-best-practices.md)
+ [Praktik terbaik Amazon Redshift untuk mendesain tabel](c_designing-tables-best-practices.md)
+ [Praktik terbaik Amazon Redshift untuk mendesain kueri](c_designing-queries-best-practices.md)