Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Buat tabel dari hasil kueri (CTAS)
<a name="ctas"></a>

A`CREATE TABLE AS SELECT`(CTAS) kueri menciptakan tabel baru di Athena dari hasil`SELECT`pernyataan dari kueri lain. Athena menyimpan file data yang dibuat oleh pernyataan CTAS di lokasi tertentu di Amazon S3. Untuk sintaks, lihat [CREATE TABLE AS](create-table-as.md).

`CREATE TABLE AS`menggabungkan pernyataan `CREATE TABLE` DDL dengan pernyataan `SELECT` DHTML dan oleh karena itu secara teknis berisi DDL dan DML.2. Namun, perhatikan bahwa untuk tujuan Service Quotas, kueri CTAS di Athena diperlakukan sebagai DHTML. Untuk informasi tentang Service Quotas di Athena, lihat. [Service Quotas](service-limits.md)

Gunakan kueri CTAS untuk: 
+ Membuat tabel dari hasil kueri dalam satu langkah, tanpa berulang kali kueri set data mentah. Hal ini memudahkan untuk bekerja dengan set data mentah.
+ Mengubah hasil kueri dan memigrasikan tabel ke dalam format tabel lain seperti Apache Iceberg. Ini meningkatkan performa kueri dan mengurangi biaya permintaan di Athena. Untuk informasi, lihat [Buat tabel Iceberg](querying-iceberg-creating-tables.md).
+ Ubah hasil kueri menjadi format penyimpanan seperti Parket dan ORC. Ini meningkatkan performa kueri dan mengurangi biaya permintaan di Athena. Untuk informasi, lihat [Gunakan format penyimpanan kolumnar](columnar-storage.md).
+ Buat salinan tabel yang ada yang hanya berisi data yang Anda butuhkan.

**Topics**
+ [Pertimbangan dan batasan untuk kueri CTAS](ctas-considerations-limitations.md)
+ [Buat kueri CTAS](ctas-console.md)
+ [Contoh CTAS](ctas-examples.md)
+ [Gunakan CTAS dan INSERT INTO untuk ETL](ctas-insert-into-etl.md)
+ [Bekerja di sekitar batas partisi 100](ctas-insert-into.md)

# Pertimbangan dan batasan untuk kueri CTAS
<a name="ctas-considerations-limitations"></a>

Bagian berikut menjelaskan pertimbangan dan batasan yang perlu diingat saat Anda menggunakan kueri `CREATE TABLE AS SELECT` (CTAS) di Athena.

## Pelajari sintaks kueri CTAS
<a name="ctas-considerations-limitations-query-syntax"></a>

Sintaks permintaan CTAS berbeda dari sintaks`CREATE [EXTERNAL] TABLE`digunakan untuk membuat tabel. Lihat [CREATE TABLE AS](create-table-as.md).

## Perbedaan antara tampilan dan kueri CTAS
<a name="ctas-considerations-limitations-queries-vs-views"></a>

Kueri CTAS menulis data baru ke lokasi tertentu di Amazon S3. Tampilan tidak menulis data apa pun. 

## Tentukan lokasi untuk hasil kueri CTAS Anda
<a name="ctas-considerations-limitations-location-of-query-results"></a>

Jika grup kerja Anda[Mengabaikan pengaturan sisi klien](workgroups-settings-override.md)untuk lokasi hasil kueri, Athena membuat tabel Anda di lokasi`s3://amzn-s3-demo-bucket/tables/<query-id>/`. Untuk melihat lokasi hasil kueri yang ditentukan untuk grup kerja,[lihat detail grup kerja](viewing-details-workgroups.md).

Jika grup kerja Anda tidak menimpa lokasi hasil kueri, Anda dapat menggunakan sintaks`WITH (external_location ='s3://amzn-s3-demo-bucket/')`dalam permintaan CTAS Anda untuk menentukan tempat hasil kueri CTAS Anda disimpan. 

**catatan**  
Parameter`external_location`properti harus menentukan lokasi yang kosong. Permintaan CTAS memeriksa bahwa lokasi jalur (awalan) dalam bucket kosong dan tidak pernah menimpa data jika lokasi sudah memiliki data di dalamnya. Untuk menggunakan lokasi yang sama lagi, hapus data di lokasi key prefix dalam bucket.

Jika Anda menghilangkan`external_location`sintaks dan tidak menggunakan pengaturan grup kerja, Athena menggunakan[Pengaturan sisi klien](query-results-specify-location-console.md)untuk lokasi hasil kueri dan membuat tabel Anda di lokasi`s3://amzn-s3-demo-bucket/<Unsaved-or-query-name>/<year>/<month/<date>/tables/<query-id>/`. 

## Temukan file yatim piatu
<a name="ctas-considerations-limitations-locating-orphaned-files"></a>

Jika `INSERT INTO` pernyataan `CTAS` atau gagal, ada kemungkinan file data yatim piatu ditinggalkan di lokasi data target untuk kueri yang gagal atau dibatalkan. Karena Athena dalam beberapa kasus tidak menghapus data dari keranjang target untuk kueri Anda, sebagian data mungkin disertakan dalam kueri berikutnya. 

Untuk menemukan file yatim piatu untuk pemeriksaan atau penghapusan, Anda dapat menggunakan file manifest data yang disediakan Athena untuk melacak daftar file yang akan ditulis. Dalam beberapa kasus yang jarang terjadi di mana kueri Athena tiba-tiba gagal, file manifes mungkin tidak ada. Anda dapat secara manual memeriksa lokasi target S3 untuk menemukan file yatim piatu. Untuk informasi selengkapnya, lihat [Mengidentifikasi file keluaran kueri](querying-finding-output-files.md#querying-identifying-output-files) dan [DataManifestLocation](https://docs.aws.amazon.com/athena/latest/APIReference/API_QueryExecutionStatistics.html#athena-Type-QueryExecutionStatistics-DataManifestLocation). 

Kami sangat menyarankan menggunakan Apache Iceberg untuk mencapai transaksi atom tabel. Untuk informasi selengkapnya, lihat [Tabel Query Apache Iceberg](querying-iceberg.md).

## Ingat bahwa klausa ORDER BY diabaikan
<a name="ctas-considerations-limitations-order-by-ignored"></a>

Dalam kueri CTAS, Athena `ORDER BY` mengabaikan klausa di `SELECT` bagian kueri.

Menurut spesifikasi SQL (ISO 9075 Bagian 2), urutan baris tabel yang ditentukan oleh ekspresi kueri dijamin hanya untuk ekspresi kueri yang segera berisi klausa. `ORDER BY` Tabel dalam SQL dalam hal apa pun secara inheren tidak berurutan, dan mengimplementasikan klausa sub kueri `ORDER BY` in akan menyebabkan kueri berkinerja buruk dan tidak menghasilkan keluaran yang diurutkan. Dengan demikian, dalam kueri CTAS Athena, tidak ada jaminan bahwa pesanan yang ditentukan oleh `ORDER BY` klausa akan dipertahankan ketika data ditulis.

## Pilih format untuk menyimpan hasil kueri Anda
<a name="ctas-considerations-limitations-formats-for-query-results"></a>

Anda dapat menyimpan hasil CTAS di`PARQUET`,`ORC`,`AVRO`,`JSON`, dan`TEXTFILE`. Pembatas multi-karakter tidak didukung untuk CTAS`TEXTFILE`format. Jika Anda tidak menentukan format penyimpanan data, hasil kueri CTAS disimpan di Parket secara default. 

Kueri CTAS tidak memerlukan menentukan a SerDe untuk menafsirkan transformasi format. Lihat [Example: Writing query results to a different format](ctas-examples.md#ctas-example-format).

## Pertimbangkan format kompresi
<a name="ctas-considerations-limitations-compression-formats"></a>

`GZIP`kompresi digunakan untuk hasil query CTAS dalam format JSON dan TEXTFILE. Untuk Parket, Anda dapat menggunakan `GZIP` atau`SNAPPY`, dan defaultnya adalah`GZIP`. Untuk ORC, Anda dapat menggunakan`LZ4`,,, atau `SNAPPY` `ZLIB``ZSTD`, dan defaultnya adalah`ZLIB`. Untuk contoh CTAS yang menentukan kompresi, lihat[Example: Specifying data storage and compression formats](ctas-examples.md#ctas-example-compression). Untuk informasi lebih lanjut tentang kompresi di Athena, lihat. [Gunakan kompresi di Athena](compression-formats.md)

## Partisi dan ember hasil Anda
<a name="ctas-considerations-limitations-partition-and-bucket-limits"></a>

Anda dapat partisi dan bucket data hasil kueri CTAS. Untuk menentukan properti dari tabel tujuan, sertakan predikat partisi dan bucketing di akhir klausa. `WITH` Untuk informasi selengkapnya, lihat [Gunakan partisi dan bucketing](ctas-partitioning-and-bucketing.md) dan [Example: Creating bucketed and partitioned tables](ctas-examples.md#ctas-example-bucketed).

Saat Anda menggunakan CTAS untuk membuat tabel yang dipartisi, Athena memiliki batas tulis 100 partisi. Untuk informasi tentang bekerja di sekitar 100 partisi pembatasan, lihat[Gunakan CTAS dan INSERT INTO untuk bekerja di sekitar batas partisi 100](ctas-insert-into.md).

## Enkripsi hasil Anda
<a name="ctas-considerations-limitations-encryption"></a>

Anda dapat mengenkripsi hasil kueri CTAS di Amazon S3, mirip dengan cara Anda mengenkripsi hasil kueri lainnya di Athena. Untuk informasi selengkapnya, lihat [Enkripsi hasil kueri Athena yang disimpan di Amazon S3](encrypting-query-results-stored-in-s3.md).

## Pengaturan pemilik bucket yang diharapkan tidak berlaku untuk CTAS
<a name="ctas-considerations-limitations-expected-bucket-owner"></a>

Untuk pernyataan CTAS, setelan pemilik bucket yang diharapkan tidak berlaku untuk lokasi tabel tujuan di Amazon S3. Setelan pemilik bucket yang diharapkan hanya berlaku untuk lokasi keluaran Amazon S3 yang Anda tentukan untuk hasil kueri Athena. Untuk informasi selengkapnya, lihat [Tentukan lokasi hasil kueri menggunakan konsol Athena](query-results-specify-location-console.md).

## Tipe data kolom dipertahankan
<a name="ctas-considerations-limitations-data-types"></a>

jenis data kolom untuk kueri CTAS adalah sama seperti yang ditentukan untuk kueri asli.

# Buat kueri CTAS di konsol Athena
<a name="ctas-console"></a>

Di konsol Athena, Anda dapat membuat kueri CTAS dari kueri lain.<a name="ctas-create-from-query"></a>

**Untuk membuat kueri CTAS dari kueri lain**

1. Jalankan kueri di editor kueri konsol Athena.

1. Di bagian bawah editor kueri, pilih opsi **Buat**, lalu pilih **Tabel dari kueri**.

1. Dalam **Buat tabel sebagai formulir pilih**, lengkapi bidang sebagai berikut:

   1. Untuk **nama Tabel**, masukkan nama untuk tabel baru Anda. Gunakan hanya huruf kecil dan garis bawah, seperti`my_select_query_parquet`.

   1. Untuk **konfigurasi Database**, gunakan opsi untuk memilih database yang ada atau membuat database.

   1. (Opsional) Dalam **konfigurasi Hasil**, untuk **hasil kueri Lokasi CTAS**, jika pengaturan lokasi hasil kueri grup kerja Anda tidak mengganti opsi ini, lakukan salah satu hal berikut:
      + Masukkan jalur ke lokasi S3 yang ada di kotak pencarian, atau pilih **Jelajahi S3** untuk memilih lokasi dari daftar.
      + Pilih **Lihat** untuk membuka halaman **Bucket di** konsol Amazon S3 tempat Anda dapat melihat informasi selengkapnya tentang bucket yang ada dan memilih atau membuat bucket dengan pengaturan Anda sendiri.

      Anda harus menentukan lokasi kosong di Amazon S3 di mana data akan dikeluarkan. Jika data sudah ada di lokasi yang Anda tentukan, kueri gagal dengan kesalahan. 

      Jika pengaturan lokasi hasil kueri grup kerja Anda mengesampingkan setelan lokasi ini, Athena akan membuat tabel Anda di lokasi `s3://amzn-s3-demo-bucket/tables/query_id/`

   1. Untuk **format Data**, tentukan format data Anda.
      + **Jenis tabel - Jenis** tabel default di Athena adalah Apache Hive. 
      + **Format file** - Pilih di antara opsi seperti CSV, TSV, JSON, Parket, atau ORC. Untuk informasi tentang format Parket dan ORC, lihat. [Gunakan format penyimpanan kolumnar](columnar-storage.md)
      + **Tulis kompresi** - (Opsional) Pilih format kompresi. Athena mendukung berbagai format kompresi untuk membaca dan menulis data, termasuk membaca dari tabel yang menggunakan berbagai format kompresi. Misalnya, Athena dapat berhasil membaca data dalam tabel yang menggunakan format file Parquet ketika beberapa file Parquet dikompresi dengan Snappy dan file Parquet lainnya dikompresi dengan GZIP. Prinsip yang sama berlaku untuk format penyimpanan ORC, file teks, dan JSON. Untuk informasi selengkapnya, lihat [Gunakan kompresi di Athena](compression-formats.md).
      + **Partisi** - (Opsional) Pilih kolom yang ingin Anda partisi. Mempartisi data Anda membatasi jumlah data yang dipindai oleh setiap kueri, sehingga meningkatkan kinerja dan mengurangi biaya. Anda dapat mempartisi data Anda dengan kunci apa pun. Untuk informasi selengkapnya, lihat [Partisi data Anda](partitions.md).
      + **Bucket** - (Opsional) Pilih kolom yang ingin Anda ember. Bucketing adalah teknik yang mengelompokkan data berdasarkan kolom tertentu bersama-sama dalam satu partisi. Kolom ini dikenal sebagai *kunci ember*. Dengan mengelompokkan data terkait ke dalam satu bucket (file dalam partisi), Anda secara signifikan mengurangi jumlah data yang dipindai oleh Athena, sehingga meningkatkan kinerja kueri dan mengurangi biaya. Untuk informasi selengkapnya, lihat [Gunakan partisi dan bucketing](ctas-partitioning-and-bucketing.md).

   1. Untuk **kueri tabel Pratinjau**, tinjau kueri Anda. Untuk sintaks kueri, lihat[CREATE TABLE AS](create-table-as.md).

   1. Pilih **Buat tabel**.

Konsol Athena memiliki template SQL yang juga dapat Anda gunakan untuk membuat kueri CTAS.<a name="ctas-create-new"></a>

**Untuk membuat kueri CTAS menggunakan template SQL**

Gunakan `CREATE TABLE AS SELECT` template untuk membuat kueri CTAS di editor kueri.

1. Di konsol Athena, di samping **Tabel dan tampilan, pilih Buat tabel****, lalu pilih CREATE** **TABLE AS SELECT**. Ini mengisi editor kueri dengan kueri CTAS dengan nilai placeholder.

1. Di editor kueri, edit kueri sesuai kebutuhan. Untuk sintaks kueri, lihat[CREATE TABLE AS](create-table-as.md).

1. Pilih **Jalankan**.

Sebagai contoh, lihat [Contoh kueri CTAS](ctas-examples.md).



# Contoh kueri CTAS
<a name="ctas-examples"></a>

Gunakan contoh berikut untuk membuat permintaan CTAS. Untuk informasi tentang sintaks aturan, lihat [CREATE TABLE AS](create-table-as.md).

Di bagian ini: 
+  [Example: Duplicating a table by selecting all columns](#ctas-example-dupe-table) 
+  [Example: Selecting specific columns from one or more tables](#ctas-example-specify-columns) 
+  [Example: Creating an empty copy of an existing table](#ctas-example-empty-table) 
+  [Example: Specifying data storage and compression formats](#ctas-example-compression) 
+  [Example: Writing query results to a different format](#ctas-example-format) 
+  [Example: Creating unpartitioned tables](#ctas-example-unpartitioned) 
+  [Example: Creating partitioned tables](#ctas-example-partitioned) 
+  [Example: Creating bucketed and partitioned tables](#ctas-example-bucketed) 
+  [Example: Creating an Iceberg table with Parquet data](#ctas-example-iceberg-parquet) 
+  [Example: Creating an Iceberg table with Avro data](#ctas-example-iceberg-avro) 
+  [Example: Creating an S3 table using CTAS](#ctas-example-s3-table) 

**Example Contoh: Menduplikasi tabel dengan memilih semua kolom**  
Contoh berikut membuat tabel dengan menyalin semua kolom dari tabel:  

```
CREATE TABLE new_table AS 
SELECT * 
FROM old_table;
```
Dalam variasi berikut dari contoh yang sama, Anda`SELECT`pernyataan juga mencakup`WHERE`Klausul. Dalam kasus ini, kueri memilih hanya baris dari tabel yang memenuhi`WHERE`Klausul:   

```
CREATE TABLE new_table AS 
SELECT * 
FROM old_table 
WHERE condition;
```

**Example Contoh: Memilih kolom tertentu dari satu atau lebih tabel**  
Contoh berikut membuat kueri baru yang berjalan pada satu set kolom dari tabel lain:  

```
CREATE TABLE new_table AS 
SELECT column_1, column_2, ... column_n 
FROM old_table;
```
Variasi ini dari contoh yang sama menciptakan tabel baru dari kolom tertentu dari beberapa tabel:   

```
CREATE TABLE new_table AS
SELECT column_1, column_2, ... column_n 
FROM old_table_1, old_table_2, ... old_table_n;
```

**Example Contoh: Membuat salinan kosong dari tabel yang ada**  
Contoh berikut menggunakan`WITH NO DATA`untuk membuat tabel baru yang kosong dan memiliki skema yang sama seperti tabel asli:  

```
CREATE TABLE new_table 
AS SELECT * 
FROM old_table
WITH NO DATA;
```

**Example Contoh: Menentukan penyimpanan data dan format kompresi**  
Dengan CTAS, Anda dapat menggunakan tabel sumber dalam satu format penyimpanan untuk membuat tabel lain dalam format penyimpanan yang berbeda.   
Gunakan `format` properti untuk menentukan`ORC`,`PARQUET`,`AVRO`,`JSON`, atau `TEXTFILE` sebagai format penyimpanan untuk tabel baru.   
Untuk format `PARQUET``ORC`,`TEXTFILE`,, dan `JSON` penyimpanan, gunakan `write_compression` properti untuk menentukan format kompresi untuk data tabel baru. Untuk informasi tentang format kompresi yang didukung oleh setiap format file, lihat[Gunakan kompresi di Athena](compression-formats.md).  
Contoh berikut menentukan bahwa data dalam tabel `new_table` disimpan dalam format Parket dan menggunakan kompresi Snappy. Kompresi default untuk Parket adalah`GZIP`.  

```
CREATE TABLE new_table
WITH (
      format = 'Parquet',
      write_compression = 'SNAPPY')
AS SELECT *
FROM old_table;
```
Contoh berikut menentukan bahwa data dalam tabel `new_table` disimpan dalam format ORC menggunakan kompresi Snappy. Kompresi default untuk ORC adalah ZLIB.  

```
CREATE TABLE new_table
WITH (format = 'ORC',
      write_compression = 'SNAPPY')
AS SELECT *
FROM old_table ;
```
Contoh berikut menentukan bahwa data dalam tabel `new_table` disimpan dalam format textfile menggunakan kompresi Snappy. Kompresi default untuk format textfile dan JSON adalah GZIP.  

```
CREATE TABLE new_table
WITH (format = 'TEXTFILE',
      write_compression = 'SNAPPY')
AS SELECT *
FROM old_table ;
```

**Example Contoh: Menulis hasil kueri ke format yang berbeda**  
Kueri CTAS berikut memilih semua catatan dari`old_table`, yang dapat disimpan dalam CSV atau format lain, dan membuat tabel baru dengan data dasar yang disimpan ke Amazon S3 dalam format ORC:   

```
CREATE TABLE my_orc_ctas_table
WITH (
      external_location = 's3://amzn-s3-demo-bucket/my_orc_stas_table/',
      format = 'ORC')
AS SELECT * 
FROM old_table;
```

**Example Contoh: Membuat tabel yang tidak dipartisi**  
Contoh berikut membuat tabel yang tidak dipartisi. Data tabel disimpan dalam format yang berbeda. Beberapa contoh ini menentukan lokasi eksternal.   
Contoh berikut membuat kueri CTAS yang menyimpan hasil sebagai file teks:  

```
CREATE TABLE ctas_csv_unpartitioned 
WITH (
     format = 'TEXTFILE', 
     external_location = 's3://amzn-s3-demo-bucket/ctas_csv_unpartitioned/') 
AS SELECT key1, name1, address1, comment1
FROM table1;
```
Pada contoh berikut, hasil disimpan di Parquet, dan lokasi hasil default digunakan:  

```
CREATE TABLE ctas_parquet_unpartitioned 
WITH (format = 'PARQUET') 
AS SELECT key1, name1, comment1
FROM table1;
```
Dalam kueri berikut, tabel disimpan dalam JSON, dan kolom tertentu dipilih dari hasil tabel asli ini:  

```
CREATE TABLE ctas_json_unpartitioned 
WITH (
     format = 'JSON',  
     external_location = 's3://amzn-s3-demo-bucket/ctas_json_unpartitioned/') 
AS SELECT key1, name1, address1, comment1
FROM table1;
```
Berikut ini adalah contoh file .  

```
CREATE TABLE ctas_orc_unpartitioned 
WITH (
     format = 'ORC') 
AS SELECT key1, name1, comment1 
FROM table1;
```
Berikut ini adalah contoh file .  

```
CREATE TABLE ctas_avro_unpartitioned 
WITH (
     format = 'AVRO', 
     external_location = 's3://amzn-s3-demo-bucket/ctas_avro_unpartitioned/') 
AS SELECT key1, name1, comment1
FROM table1;
```

**Example Contoh: Membuat tabel yang dipartisi**  
Contoh berikut menunjukkan`CREATE TABLE AS SELECT`query untuk tabel dipartisi dalam format penyimpanan yang berbeda, menggunakan`partitioned_by`, dan properti lainnya di`WITH`Klausul. Untuk sintaks, lihat[Properti tabel CTAS](create-table-as.md#ctas-table-properties). Untuk informasi selengkapnya tentang memilih kolom untuk partisi, lihat[Gunakan partisi dan bucketing](ctas-partitioning-and-bucketing.md).  
Daftar kolom partisi pada akhir daftar kolom di`SELECT`. Anda dapat mempartisi dengan lebih dari satu kolom, dan memiliki hingga 100 partisi unik dan kombinasi bucket. Misalnya, Anda dapat memiliki 100 partisi jika tidak ada bucket yang ditentukan.

```
CREATE TABLE ctas_csv_partitioned 
WITH (
     format = 'TEXTFILE',  
     external_location = 's3://amzn-s3-demo-bucket/ctas_csv_partitioned/', 
     partitioned_by = ARRAY['key1']) 
AS SELECT name1, address1, comment1, key1
FROM tables1;
```

```
CREATE TABLE ctas_json_partitioned 
WITH (
     format = 'JSON', 
     external_location = 's3://amzn-s3-demo-bucket/ctas_json_partitioned/', 
     partitioned_by = ARRAY['key1']) 
AS select name1, address1, comment1, key1 
FROM table1;
```

**Example Contoh: Membuat tabel berember dan dipartisi**  
Contoh berikut menunjukkan`CREATE TABLE AS SELECT`query yang menggunakan partisi dan bucketing untuk menyimpan hasil kueri di Amazon S3. Hasil tabel dipartisi dan bucketed oleh kolom yang berbeda. Athena mendukung maksimal 100 kombinasi bucket dan partisi yang unik. Misalnya, jika Anda membuat tabel dengan lima bucket, 20 partisi dengan lima bucket masing-masing didukung. Untuk sintaks, lihat[Properti tabel CTAS](create-table-as.md#ctas-table-properties).  
Untuk informasi tentang memilih kolom untuk bucketing, lihat[Gunakan partisi dan bucketing](ctas-partitioning-and-bucketing.md).  

```
CREATE TABLE ctas_avro_bucketed 
WITH (
      format = 'AVRO', 
      external_location = 's3://amzn-s3-demo-bucket/ctas_avro_bucketed/', 
      partitioned_by = ARRAY['nationkey'], 
      bucketed_by = ARRAY['mktsegment'], 
      bucket_count = 3) 
AS SELECT key1, name1, address1, phone1, acctbal, mktsegment, comment1, nationkey 
FROM table1;
```

**Example Contoh: Membuat tabel Gunung Es dengan data Parket**  
Contoh berikut membuat tabel Iceberg dengan file data Parket. File dipartisi berdasarkan bulan menggunakan `dt` kolom di. `table1` Contoh memperbarui properti retensi pada tabel sehingga 10 snapshot dipertahankan secara default pada setiap cabang dalam tabel. Snapshot dalam 7 hari terakhir juga dipertahankan. Untuk informasi lebih lanjut tentang properti tabel Gunung Es di Athena, lihat. [Tentukan properti tabel](querying-iceberg-creating-tables.md#querying-iceberg-table-properties)  

```
CREATE TABLE ctas_iceberg_parquet
WITH (table_type = 'ICEBERG',
      format = 'PARQUET', 
      location = 's3://amzn-s3-demo-bucket/ctas_iceberg_parquet/', 
      is_external = false,
      partitioning = ARRAY['month(dt)'],
      vacuum_min_snapshots_to_keep = 10,
      vacuum_max_snapshot_age_seconds = 604800
   ) 
AS SELECT key1, name1, dt FROM table1;
```

**Example Contoh: Membuat tabel Iceberg dengan data Avro**  
Contoh berikut membuat tabel Iceberg dengan file data Avro dipartisi oleh. `key1`  

```
CREATE TABLE ctas_iceberg_avro
WITH ( format = 'AVRO', 
       location = 's3://amzn-s3-demo-bucket/ctas_iceberg_avro/', 
       is_external = false,
       table_type = 'ICEBERG',
       partitioning = ARRAY['key1']) 
AS SELECT key1, name1, date FROM table1;
```

**Example Contoh: Membuat Tabel S3 menggunakan CTAS**  
Contoh berikut membuat Tabel S3 menggunakan CTAS. Perhatikan bahwa properti lokasi dihilangkan, dan `table_type` defaultnya adalah: `ICEBERG`  

```
CREATE TABLE "s3tablescatalog/amzn-s3-demo-bucket"."namespace"."s3-table-name"
WITH (
    format = 'PARQUET'
)
AS SELECT *
FROM source_table;
```
Anda dapat menentukan semua properti tabel Iceberg lainnya, seperti partisi dan bucketing dengan sintaks yang sama seperti tabel Iceberg biasa.

# Gunakan CTAS dan INSERT INTO untuk ETL dan analisis data
<a name="ctas-insert-into-etl"></a>

Anda dapat menggunakan pernyataan Create Table as Select ([CTAS](ctas.md)) dan [INSERT INTO](insert-into.md) di Athena untuk extract, transform, and load (ETL) data ke Amazon S3 untuk pemrosesan data. Topik ini menunjukkan cara menggunakan pernyataan ini untuk partisi dan mengkonversi set data ke format data columnar untuk mengoptimalkan untuk analisis data.

Pernyataan CTAS menggunakan kueri [SELECT](select.md) standar untuk membuat tabel baru. Anda dapat menggunakan pernyataan CTAS untuk membuat subset dari data Anda untuk analisis. Dalam satu pernyataan CTAS, Anda dapat partisi data, menentukan kompresi, dan mengkonversi data ke dalam format columnar seperti Apache Parquet atau Apache ORC. Saat Anda menjalankan permintaan CTAS, tabel dan partisi yang dibuat secara otomatis ditambahkan ke[AWS Glue Data Catalog](https://aws.amazon.com/glue). Ini membuat tabel baru dan partisi yang menciptakan segera tersedia untuk kueri berikutnya.

INSERT INTO pernyataan memasukkan baris baru ke dalam tabel tujuan berdasarkan pernyataan kueri SELECT yang berjalan pada tabel sumber. Anda dapat menggunakan INSERT INTO pernyataan untuk mengubah dan memuat data tabel sumber dalam format CSV ke data tabel tujuan menggunakan semua transformasi yang didukung CTAS.

## Ikhtisar
<a name="ctas-insert-into-etl-overview"></a>

Di Athena, menggunakan pernyataan CTAS untuk melakukan konversi batch awal data. Kemudian gunakan beberapa INSERT INTO pernyataan untuk membuat update inkremental ke tabel yang dibuat oleh pernyataan CTAS.

**Langkah-langkah**
+ [Langkah 1: Buat tabel berdasarkan dataset asli](#ctas-insert-into-etl-step-1-create-a-table-based-on-the-original-dataset)
+  [Langkah 2: Gunakan CTAS untuk mempartisi, mengonversi, dan mengompres data](#ctas-insert-into-etl-step-2-use-ctas-to-partition-convert-and-compress-the-data) 
+  [Langkah 3: Gunakan INSERT INTO untuk menambahkan data](#ctas-insert-into-etl-step-3-use-insert-into-to-add-data) 
+  [Langkah 4: Ukur perbedaan kinerja dan biaya](#ctas-insert-into-etl-step-4-measure-performance-and-cost-differences) 

## Langkah 1: Buat tabel berdasarkan dataset asli
<a name="ctas-insert-into-etl-step-1-create-a-table-based-on-the-original-dataset"></a>

Contoh dalam topik ini menggunakan subset Amazon S3 yang dapat dibaca dari kumpulan data harian jaringan [klimatologi historis global NOAA](https://registry.opendata.aws/noaa-ghcn/) (GHCN-D) yang tersedia untuk umum. Data di Amazon S3 memiliki karakteristik sebagai berikut.

```
Location: s3://aws-bigdata-blog/artifacts/athena-ctas-insert-into-blog/
Total objects: 41727
Size of CSV dataset: 11.3 GB
Region: us-east-1
```

Data asli disimpan di Amazon S3 tanpa partisi. Data dalam format CSV dalam fail seperti berikut.

```
2019-10-31 13:06:57  413.1 KiB artifacts/athena-ctas-insert-into-blog/2010.csv0000
2019-10-31 13:06:57  412.0 KiB artifacts/athena-ctas-insert-into-blog/2010.csv0001
2019-10-31 13:06:57   34.4 KiB artifacts/athena-ctas-insert-into-blog/2010.csv0002
2019-10-31 13:06:57  412.2 KiB artifacts/athena-ctas-insert-into-blog/2010.csv0100
2019-10-31 13:06:57  412.7 KiB artifacts/athena-ctas-insert-into-blog/2010.csv0101
```

Ukuran file dalam sampel ini relatif kecil. Dengan menggabungkan mereka ke dalam file yang lebih besar, Anda dapat mengurangi jumlah total file, memungkinkan performa kueri yang lebih baik. Anda dapat menggunakan CTAS dan INSERT INTO pernyataan untuk meningkatkan performa kueri.

**Untuk membuat basis data dan tabel berdasarkan set data sampel**

1. Di konsol Athena, pilih **US East (Virginia N.).** Wilayah AWS Pastikan untuk menjalankan semua pertanyaan dalam tutorial ini di`us-east-1`.

1. Dalam editor permintaan Athena, jalankan perintah[BUAT BASIS DATA](create-database.md)Untuk membuat basis data. 

   ```
   CREATE DATABASE blogdb
   ```

1. Jalankan pernyataan berikut untuk[Untuk membuat tabel](create-table.md).

   ```
   CREATE EXTERNAL TABLE `blogdb`.`original_csv` (
     `id` string,
     `date` string,
     `element` string,
     `datavalue` bigint,
     `mflag` string,
     `qflag` string,
     `sflag` string,
     `obstime` bigint)
   ROW FORMAT DELIMITED
     FIELDS TERMINATED BY ','
   STORED AS INPUTFORMAT
     'org.apache.hadoop.mapred.TextInputFormat'
   OUTPUTFORMAT
     'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
   LOCATION
     's3://aws-bigdata-blog/artifacts/athena-ctas-insert-into-blog/'
   ```

## Langkah 2: Gunakan CTAS untuk mempartisi, mengonversi, dan mengompres data
<a name="ctas-insert-into-etl-step-2-use-ctas-to-partition-convert-and-compress-the-data"></a>

Setelah Anda membuat tabel, Anda dapat menggunakan[CTAS](ctas.md)untuk mengkonversi data ke format Parquet dengan kompresi Snappy dan partisi data per tahun.

Tabel yang Anda buat di Langkah 1 memiliki`date`lapangan dengan tanggal diformat sebagai`YYYYMMDD`(misalnya,`20100104`). Karena tabel baru akan dipartisi pada`year`, contoh pernyataan dalam prosedur berikut menggunakan fungsi Presto`substr("date",1,4)`untuk mengekstrak`year`nilai dari`date`Bidang.

**Untuk mengonversi data ke format parket dengan kompresi tajam, partisi berdasarkan tahun**
+ Jalankan pernyataan CTAS berikut, ganti *your-bucket* dengan lokasi bucket Amazon S3 Anda.

  ```
  CREATE table new_parquet
  WITH (format='PARQUET',
  parquet_compression='SNAPPY',
  partitioned_by=array['year'],
  external_location = 's3://amzn-s3-demo-bucket/optimized-data/')
  AS
  SELECT id,
           date,
           element,
           datavalue,
           mflag,
           qflag,
           sflag,
           obstime,
           substr("date",1,4) AS year
  FROM original_csv
  WHERE cast(substr("date",1,4) AS bigint) >= 2015
          AND cast(substr("date",1,4) AS bigint) <= 2019
  ```
**catatan**  
Dalam contoh ini, tabel yang Anda buat hanya mencakup data dari 2015 hingga 2019. Pada Langkah 3, Anda menambahkan data baru ke tabel ini menggunakan INSERT INTO perintah.

Saat permintaan selesai, gunakan prosedur berikut untuk memverifikasi output di lokasi Amazon S3 yang Anda tentukan dalam pernyataan CTAS.

**Untuk melihat partisi dan file Parquet yang dibuat oleh pernyataan CTAS**

1. Untuk menampilkan partisi yang dibuat, jalankan AWS CLI perintah berikut. Pastikan untuk menyertakan garis miring ke depan akhir (/).

   ```
   aws s3 ls s3://amzn-s3-demo-bucket/optimized-data/
   ```

   Output menunjukkan partisi.

   ```
         PRE year=2015/
         PRE year=2016/
         PRE year=2017/
         PRE year=2018/
         PRE year=2019/
   ```

1. Untuk melihat file Parquet, jalankan perintah berikut. Perhatikan bahwa opsi `|` *head-5*, yang membatasi output untuk lima hasil pertama, tidak tersedia pada Windows.

   ```
   aws s3 ls s3://amzn-s3-demo-bucket/optimized-data/ --recursive --human-readable | head -5
   ```

   Output menyerupai berikut.

   ```
   2019-10-31 14:51:05    7.3 MiB optimized-data/year=2015/20191031_215021_00001_3f42d_1be48df2-3154-438b-b61d-8fb23809679d
   2019-10-31 14:51:05    7.0 MiB optimized-data/year=2015/20191031_215021_00001_3f42d_2a57f4e2-ffa0-4be3-9c3f-28b16d86ed5a
   2019-10-31 14:51:05    9.9 MiB optimized-data/year=2015/20191031_215021_00001_3f42d_34381db1-00ca-4092-bd65-ab04e06dc799
   2019-10-31 14:51:05    7.5 MiB optimized-data/year=2015/20191031_215021_00001_3f42d_354a2bc1-345f-4996-9073-096cb863308d
   2019-10-31 14:51:05    6.9 MiB optimized-data/year=2015/20191031_215021_00001_3f42d_42da4cfd-6e21-40a1-8152-0b902da385a1
   ```

## Langkah 3: Gunakan INSERT INTO untuk menambahkan data
<a name="ctas-insert-into-etl-step-3-use-insert-into-to-add-data"></a>

Pada langkah 2, Anda menggunakan CTAS untuk membuat tabel dengan partisi untuk tahun 2015 hingga 2019. Namun, set data asli juga berisi data untuk tahun 2010 hingga 2014. Sekarang Anda menambahkan data yang menggunakan[SISIPAN KE](insert-into.md).

**Untuk menambahkan data ke tabel menggunakan satu atau lebih INSERT INTO pernyataan**

1. Jalankan perintah INSERT INTO berikut, menentukan tahun sebelum 2015 di klausa WHERE.

   ```
   INSERT INTO new_parquet
   SELECT id,
            date,
            element,
            datavalue,
            mflag,
            qflag,
            sflag,
            obstime,
            substr("date",1,4) AS year
   FROM original_csv
   WHERE cast(substr("date",1,4) AS bigint) < 2015
   ```

1. Jalankan`aws s3 ls`Perintah lagi, menggunakan sintaks berikut.

   ```
   aws s3 ls s3://amzn-s3-demo-bucket/optimized-data/
   ```

   Output menunjukkan partisi baru.

   ```
         PRE year=2010/
         PRE year=2011/
         PRE year=2012/
         PRE year=2013/
         PRE year=2014/
         PRE year=2015/
         PRE year=2016/
         PRE year=2017/
         PRE year=2018/
         PRE year=2019/
   ```

1. Untuk melihat pengurangan ukuran set data yang diperoleh dengan menggunakan kompresi dan penyimpanan kolumnar dalam format Parquet, jalankan perintah berikut.

   ```
   aws s3 ls s3://amzn-s3-demo-bucket/optimized-data/ --recursive --human-readable --summarize
   ```

   Hasil berikut menunjukkan bahwa ukuran set data setelah Parquet dengan kompresi Snappy adalah 1,2 GB.

   ```
   ...
   2020-01-22 18:12:02 2.8 MiB optimized-data/year=2019/20200122_181132_00003_nja5r_f0182e6c-38f4-4245-afa2-9f5bfa8d6d8f
   2020-01-22 18:11:59 3.7 MiB optimized-data/year=2019/20200122_181132_00003_nja5r_fd9906b7-06cf-4055-a05b-f050e139946e
   Total Objects: 300
        Total Size: 1.2 GiB
   ```

1. Jika lebih banyak data CSV ditambahkan ke tabel asli, Anda dapat menambahkan data tersebut ke tabel Parquet dengan menggunakan INSERT INTO pernyataan. Sebagai contoh, jika Anda memiliki data baru untuk tahun 2020, Anda bisa menjalankan berikut INSERT INTO pernyataan. Pernyataan itu menambahkan data dan partisi yang relevan untuk`new_parquet`Tabel.

   ```
   INSERT INTO new_parquet
   SELECT id,
            date,
            element,
            datavalue,
            mflag,
            qflag,
            sflag,
            obstime,
            substr("date",1,4) AS year
   FROM original_csv
   WHERE cast(substr("date",1,4) AS bigint) = 2020
   ```
**catatan**  
Pernyataan INSERT INTO mendukung menulis maksimal 100 partisi ke tabel tujuan. Namun, untuk menambahkan lebih dari 100 partisi, Anda dapat menjalankan beberapa INSERT INTO pernyataan. Untuk informasi selengkapnya, lihat [Gunakan CTAS dan INSERT INTO untuk bekerja di sekitar batas partisi 100](ctas-insert-into.md).

## Langkah 4: Ukur perbedaan kinerja dan biaya
<a name="ctas-insert-into-etl-step-4-measure-performance-and-cost-differences"></a>

Setelah Anda mengubah data, Anda dapat mengukur performa keuntungan dan penghematan biaya dengan menjalankan kueri yang sama pada tabel baru dan lama dan membandingkan hasil.

**catatan**  
Untuk informasi biaya per permintaan Athena, lihat[Harga Amazon Athena](https://aws.amazon.com/athena/pricing).

**Untuk mengukur keuntungan performa dan perbedaan biaya**

1. Menjalankan kueri berikut pada tabel asli. Kueri menemukan jumlah yang berbeda IDs untuk setiap nilai tahun ini.

   ```
   SELECT substr("date",1,4) as year,
          COUNT(DISTINCT id)
   FROM original_csv
   GROUP BY 1 ORDER BY 1 DESC
   ```

1. Perhatikan waktu yang permintaan berlari dan jumlah data yang dipindai.

1. Menjalankan kueri yang sama pada tabel baru, mencatat runtime kueri dan jumlah data yang dipindai.

   ```
   SELECT year,
     COUNT(DISTINCT id)
   FROM new_parquet
   GROUP BY 1 ORDER BY 1 DESC
   ```

1. Bandingkan hasilnya dan hitung perbedaan performa dan biaya. Hasil contoh berikut menunjukkan bahwa permintaan tes di tabel baru lebih cepat dan lebih murah daripada permintaan di tabel tua.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/athena/latest/ug/ctas-insert-into-etl.html)

1. Menjalankan kueri contoh berikut pada tabel asli. Kueri menghitung suhu maksimum rata-rata (Celcius), suhu minimum rata-rata (Celcius), dan curah hujan rata-rata (mm) untuk Bumi pada tahun 2018.

   ```
   SELECT element, round(avg(CAST(datavalue AS real)/10),2) AS value
   FROM original_csv
   WHERE element IN ('TMIN', 'TMAX', 'PRCP') AND substr("date",1,4) = '2018'
   GROUP BY 1
   ```

1. Perhatikan waktu yang permintaan berlari dan jumlah data yang dipindai.

1. Menjalankan kueri yang sama pada tabel baru, mencatat runtime kueri dan jumlah data yang dipindai.

   ```
   SELECT element, round(avg(CAST(datavalue AS real)/10),2) AS value
   FROM new_parquet
   WHERE element IN ('TMIN', 'TMAX', 'PRCP') and year = '2018'
   GROUP BY 1
   ```

1. Bandingkan hasilnya dan hitung perbedaan performa dan biaya. Hasil contoh berikut menunjukkan bahwa permintaan tes di tabel baru lebih cepat dan lebih murah daripada permintaan di tabel tua.  
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/athena/latest/ug/ctas-insert-into-etl.html)

## Ringkasan
<a name="ctas-insert-into-etl-summary"></a>

Topik ini menunjukkan cara untuk melakukan operasi ETL menggunakan CTAS dan INSERT INTO pernyataan di Athena. Anda melakukan rangkaian transformasi pertama menggunakan pernyataan CTAS yang mengubah data ke format Parquet dengan kompresi Snappy. Pernyataan CTAS juga dikonversi set data dari non-dipartisi untuk dipartisi. Ini mengurangi ukurannya dan menurunkan biaya menjalankan kueri. Saat data baru menjadi tersedia, Anda dapat menggunakan INSERT INTO pernyataan untuk mengubah dan memuat data ke dalam tabel yang Anda buat dengan pernyataan CTAS.

# Gunakan CTAS dan INSERT INTO untuk bekerja di sekitar batas partisi 100
<a name="ctas-insert-into"></a>

Athena memiliki batas 100 partisi per `CREATE TABLE AS SELECT` ([CTAS](ctas.md)) kueri. Demikian pula, Anda dapat menambahkan maksimal 100 partisi ke tabel tujuan dengan[SISIPAN KE](https://docs.aws.amazon.com/athena/latest/ug/insert-into.html).

Jika Anda melebihi batasan ini, Anda mungkin menerima pesan kesalahan HIVE\$1TOO\$1MANY\$1OPEN\$1PARTITIONS: Melebihi batas 100 penulis terbuka untuk partisi/ember. Untuk mengatasi batasan ini, Anda dapat menggunakan pernyataan CTAS dan serangkaian `INSERT INTO` pernyataan yang membuat atau menyisipkan hingga 100 partisi masing-masing.

Contoh dalam topik ini menggunakan database bernama `tpch100` yang datanya berada di lokasi bucket Amazon S3 s3://amzn-s3-demo-bucket/.

**Untuk menggunakan CTAS dan INSERT INTO untuk membuat tabel lebih dari 100 partisi**

1. Menggunakan`CREATE EXTERNAL TABLE`pernyataan untuk membuat tabel dipartisi pada bidang yang Anda inginkan.

   Contoh pernyataan berikut partisi data dengan kolom`l_shipdate`. Tabel ini memiliki 2525 partisi.

   ```
   CREATE EXTERNAL TABLE `tpch100.lineitem_parq_partitioned`(
     `l_orderkey` int, 
     `l_partkey` int, 
     `l_suppkey` int, 
     `l_linenumber` int, 
     `l_quantity` double, 
     `l_extendedprice` double, 
     `l_discount` double, 
     `l_tax` double, 
     `l_returnflag` string, 
     `l_linestatus` string, 
     `l_commitdate` string, 
     `l_receiptdate` string, 
     `l_shipinstruct` string, 
     `l_comment` string)
   PARTITIONED BY ( 
     `l_shipdate` string)
   ROW FORMAT SERDE 
     'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe' STORED AS INPUTFORMAT 
     'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat' OUTPUTFORMAT 
     'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat' LOCATION   's3://amzn-s3-demo-bucket/lineitem/'
   ```

1. Jalankan`SHOW PARTITIONS <table_name>`perintah seperti berikut untuk daftar partisi.

   ```
   SHOW PARTITIONS lineitem_parq_partitioned
   ```

   Berikut ini adalah hasil sampel parsial.

   ```
   /*
   l_shipdate=1992-01-02
   l_shipdate=1992-01-03
   l_shipdate=1992-01-04
   l_shipdate=1992-01-05
   l_shipdate=1992-01-06
   
   ...
   
   l_shipdate=1998-11-24
   l_shipdate=1998-11-25
   l_shipdate=1998-11-26
   l_shipdate=1998-11-27
   l_shipdate=1998-11-28
   l_shipdate=1998-11-29
   l_shipdate=1998-11-30
   l_shipdate=1998-12-01
   */
   ```

1. Menjalankan kueri CTAS untuk membuat tabel dipartisi. 

   Contoh berikut membuat tabel yang disebut`my_lineitem_parq_partitioned`dan menggunakan`WHERE `klausa untuk membatasi`DATE`ke awal dari`1992-02-01`. Karena set data sampel dimulai dengan Januari 1992, hanya partisi untuk Januari 1992 dibuat.

   ```
   CREATE table my_lineitem_parq_partitioned
   WITH (partitioned_by = ARRAY['l_shipdate']) AS
   SELECT l_orderkey,
            l_partkey,
            l_suppkey,
            l_linenumber,
            l_quantity,
            l_extendedprice,
            l_discount,
            l_tax,
            l_returnflag,
            l_linestatus,
            l_commitdate,
            l_receiptdate,
            l_shipinstruct,
            l_comment,
            l_shipdate
   FROM tpch100.lineitem_parq_partitioned
   WHERE cast(l_shipdate as timestamp) < DATE ('1992-02-01');
   ```

1. Jalankan`SHOW PARTITIONS`perintah untuk memverifikasi bahwa tabel berisi partisi yang Anda inginkan.

   ```
   SHOW PARTITIONS my_lineitem_parq_partitioned;
   ```

   Partisi dalam contoh adalah dari Januari 1992.

   ```
   /*
   l_shipdate=1992-01-02
   l_shipdate=1992-01-03
   l_shipdate=1992-01-04
   l_shipdate=1992-01-05
   l_shipdate=1992-01-06
   l_shipdate=1992-01-07
   l_shipdate=1992-01-08
   l_shipdate=1992-01-09
   l_shipdate=1992-01-10
   l_shipdate=1992-01-11
   l_shipdate=1992-01-12
   l_shipdate=1992-01-13
   l_shipdate=1992-01-14
   l_shipdate=1992-01-15
   l_shipdate=1992-01-16
   l_shipdate=1992-01-17
   l_shipdate=1992-01-18
   l_shipdate=1992-01-19
   l_shipdate=1992-01-20
   l_shipdate=1992-01-21
   l_shipdate=1992-01-22
   l_shipdate=1992-01-23
   l_shipdate=1992-01-24
   l_shipdate=1992-01-25
   l_shipdate=1992-01-26
   l_shipdate=1992-01-27
   l_shipdate=1992-01-28
   l_shipdate=1992-01-29
   l_shipdate=1992-01-30
   l_shipdate=1992-01-31
   */
   ```

1. Menggunakan`INSERT INTO`pernyataan untuk menambahkan partisi ke tabel. 

   Contoh berikut menambahkan partisi untuk tanggal dari bulan Februari 1992.

   ```
   INSERT INTO my_lineitem_parq_partitioned
   SELECT l_orderkey,
            l_partkey,
            l_suppkey,
            l_linenumber,
            l_quantity,
            l_extendedprice,
            l_discount,
            l_tax,
            l_returnflag,
            l_linestatus,
            l_commitdate,
            l_receiptdate,
            l_shipinstruct,
            l_comment,
            l_shipdate
   FROM tpch100.lineitem_parq_partitioned
   WHERE cast(l_shipdate as timestamp) >= DATE ('1992-02-01')
   AND cast(l_shipdate as timestamp) < DATE ('1992-03-01');
   ```

1. Jalankan lagi `SHOW PARTITIONS`.

   ```
   SHOW PARTITIONS my_lineitem_parq_partitioned;
   ```

   Tabel contoh sekarang memiliki partisi dari Januari dan Februari 1992.

   ```
   /*
   l_shipdate=1992-01-02
   l_shipdate=1992-01-03
   l_shipdate=1992-01-04
   l_shipdate=1992-01-05
   l_shipdate=1992-01-06
   
   ...
   
   l_shipdate=1992-02-20
   l_shipdate=1992-02-21
   l_shipdate=1992-02-22
   l_shipdate=1992-02-23
   l_shipdate=1992-02-24
   l_shipdate=1992-02-25
   l_shipdate=1992-02-26
   l_shipdate=1992-02-27
   l_shipdate=1992-02-28
   l_shipdate=1992-02-29
   */
   ```

1. Lanjutkan menggunakan `INSERT INTO` pernyataan yang membaca dan menambahkan tidak lebih dari 100 partisi masing-masing. Lanjutkan sampai Anda mencapai jumlah partisi yang Anda butuhkan.
**penting**  
Saat menyetel`WHERE`kondisi, pastikan bahwa permintaan tidak tumpang tindih. Jika tidak, beberapa partisi mungkin memiliki data yang diduplikasi.