Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memulai dengan Amazon Keyspaces (untuk Apache Cassandra)
Jika Anda baru mengenal Apache Cassandra dan Amazon Keyspaces, tutorial ini memandu Anda untuk menginstal program dan alat yang diperlukan untuk menggunakan Amazon Keyspaces dengan sukses. Anda akan belajar cara membuat keyspace dan tabel menggunakan Cassandra Query Language (CQL), the Konsol Manajemen AWS, atau the (). AWS Command Line Interface AWS CLI Anda kemudian menggunakan Cassandra Query Language (CQL) untuk melakukan operasi membuat, membaca, memperbarui, dan menghapus (CRUD) pada data di tabel Amazon Keyspaces Anda.
Tutorial ini mencakup langkah-langkah berikut.
+ **Prasyarat** - Sebelum memulai tutorial, ikuti petunjuk AWS penyiapan untuk mendaftar AWS dan membuat pengguna IAM dengan akses ke Amazon Keyspaces. Kemudian Anda mengatur `cqhsh-expansion` dan AWS CloudShell. Atau Anda dapat menggunakan AWS CLI untuk membuat sumber daya di Amazon Keyspaces.
+ **Langkah 1: Buat keyspace dan table** - Di bagian ini, Anda akan membuat keyspace bernama “catalog” dan tabel bernama “book\$1awards” di dalamnya. Anda akan menentukan kolom tabel, tipe data, kunci partisi, dan kolom pengelompokan menggunakan Konsol Manajemen AWS, CQL, atau kolom. AWS CLI
+ **Langkah 2: Lakukan operasi CRUD** - Di sini, Anda akan menggunakan `cqlsh-expansion` in CloudShell untuk menyisipkan, membaca, memperbarui, dan menghapus data di tabel “book\$1awards”. Anda akan belajar cara menggunakan berbagai pernyataan CQL seperti SELECT, INSERT, UPDATE, dan DELETE, dan berlatih memfilter dan memodifikasi data.
+ **Langkah 3: Bersihkan sumber daya** — Untuk menghindari biaya untuk sumber daya yang tidak digunakan, bagian ini memandu Anda menghapus tabel “book\$1awards” dan keyspace “katalog” menggunakan konsol, CQL, atau. AWS CLI
Untuk tutorial untuk terhubung secara terprogram ke Amazon Keyspaces menggunakan driver klien Apache Cassandra yang berbeda, lihat. [Menggunakan driver klien Cassandra untuk mengakses Amazon Keyspaces secara terprogram](programmatic.drivers.md) Untuk contoh kode yang menggunakan berbeda AWS SDKs, lihat [Contoh kode untuk Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/latest/devguide/service_code_examples.html) yang digunakan. AWS SDKs
**Topics**
+ [Prasyarat dan pertimbangan tutorial](getting-started.before-you-begin.md)
+ [Buat ruang kunci di Amazon Keyspaces](getting-started.keyspaces.md)
+ [Periksa status pembuatan keyspace di Amazon Keyspaces](keyspaces-create.md)
+ [Buat tabel di Amazon Keyspaces](getting-started.tables.md)
+ [Periksa status pembuatan tabel di Amazon Keyspaces](tables-create.md)
+ [Membuat, membaca, memperbarui, dan menghapus data (CRUD) menggunakan CQL di Amazon Keyspaces](getting-started.dml.md)
+ [Hapus tabel di Amazon Keyspaces](getting-started.clean-up.table.md)
+ [Hapus ruang kunci di Amazon Keyspaces](getting-started.clean-up.keyspace.md)
# Prasyarat dan pertimbangan tutorial
Sebelum Anda dapat memulai dengan Amazon Keyspaces, ikuti petunjuk AWS penyiapan di. [Mengakses Amazon Keyspaces (untuk Apache Cassandra)](accessing.md) Langkah-langkah ini termasuk mendaftar AWS dan membuat pengguna AWS Identity and Access Management (IAM) dengan akses ke Amazon Keyspaces.
Untuk menyelesaikan semua langkah tutorial, Anda perlu menginstal`cqlsh`. Anda dapat mengikuti instruksi pengaturan di[Menggunakan `cqlsh` untuk terhubung ke Amazon Keyspaces](programmatic.cqlsh.md).
Untuk mengakses Amazon Keyspaces menggunakan `cqlsh` atau AWS CLI, sebaiknya gunakan. AWS CloudShell CloudShelladalah shell pra-otentikasi berbasis browser yang dapat Anda luncurkan langsung dari file. Konsol Manajemen AWS Anda dapat menjalankan perintah AWS Command Line Interface (AWS CLI) terhadap Amazon Keyspaces menggunakan shell pilihan Anda (Bash, PowerShell atau Z shell). Untuk menggunakannya`cqlsh`, Anda harus menginstal`cqlsh-expansion`. Untuk petunjuk `cqlsh-expansion` penginstalan, lihat[Menggunakan untuk terhubung `cqlsh-expansion` ke Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh). Untuk informasi lebih lanjut tentang CloudShell lihat[Menggunakan AWS CloudShell untuk mengakses Amazon Keyspaces](using-aws-with-cloudshell.md).
Untuk menggunakan AWS CLI cara membuat, melihat, dan menghapus sumber daya di Amazon Keyspaces, ikuti petunjuk penyiapan di. [Mengunduh dan Mengkonfigurasi AWS CLI](access.cli.md#access.cli.installcli)
Setelah menyelesaikan langkah-langkah prasyarat, lanjutkan ke. [Buat ruang kunci di Amazon Keyspaces](getting-started.keyspaces.md)
# Buat ruang kunci di Amazon Keyspaces
Di bagian ini, Anda membuat ruang kunci menggunakan konsol,`cqlsh`, atau. AWS CLI
**catatan**
Sebelum Anda mulai, pastikan bahwa Anda telah mengkonfigurasi semua [prasyarat tutorial](getting-started.before-you-begin.md).
Sebuah *keyspace* mengelompokkan tabel terkait yang relevan untuk satu atau beberapa aplikasi. Sebuah keyspace berisi satu atau lebih tabel dan mendefinisikan strategi replikasi untuk semua tabel yang dikandungnya. Untuk informasi selengkapnya tentang ruang kunci, lihat topik berikut:
+ Pernyataan bahasa definisi data (DDL) dalam referensi bahasa CQL: [Keyspaces](cql.ddl.keyspace.md)
+ [Kuota untuk Amazon Keyspaces (untuk Apache Cassandra)](quotas.md)
Dalam tutorial ini kita membuat ruang kunci Single-region, dan strategi replikasi keyspace adalah. `SingleRegionStrategy` Menggunakan`SingleRegionStrategy`, Amazon Keyspaces mereplikasi data di tiga [Availability Zone](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) menjadi satu. Wilayah AWS Untuk mempelajari cara membuat ruang kunci Multi-wilayah, lihat. [Buat ruang kunci Multi-wilayah di Amazon Keyspaces](keyspaces-mrr-create.md)
## Menggunakan konsol
**Untuk membuat ruang kunci menggunakan konsol**
1. [Masuk ke Konsol Manajemen AWS, dan buka konsol Amazon Keyspaces di https://console.aws.amazon.com/keyspaces/ rumah.](https://console.aws.amazon.com/keyspaces/home)
1. Di panel navigasi, pilih **Keyspaces**.
1. Pilih **Buat ruang kunci**.
1. Di kotak **nama Keyspace**, masukkan **catalog** sebagai nama untuk ruang kunci Anda.
**Kendala nama:**
+ Nama tidak bisa kosong.
+ Karakter yang diizinkan: karakter alfanumerik dan garis bawah (). `_`
+ Panjang maksimum adalah 48 karakter.
1. Di bawah **Wilayah AWS**, konfirmasikan bahwa **replikasi Wilayah Tunggal** adalah strategi replikasi untuk ruang kunci.
1. Untuk membuat keyspace, pilih **Create keyspace**.
1. Verifikasi bahwa ruang kunci `catalog` dibuat dengan melakukan hal berikut:
1. Di panel navigasi, pilih **Keyspaces**.
1. Temukan ruang kunci Anda `catalog` dalam daftar ruang kunci.
## Menggunakan CQL
Prosedur berikut membuat keyspace menggunakan CQL.
**Untuk membuat keyspace menggunakan CQL**
1. Buka AWS CloudShell dan sambungkan ke Amazon Keyspaces menggunakan perintah berikut. Pastikan untuk memperbarui *us-east-1* dengan Wilayah Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Output dari perintah itu akan terlihat seperti ini.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
```
1. Buat keyspace Anda menggunakan perintah CQL berikut.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
`SingleRegionStrategy`menggunakan faktor replikasi tiga dan mereplikasi data di tiga AWS Availability Zone di Wilayahnya.
**catatan**
Amazon Keyspaces default semua input ke huruf kecil kecuali Anda melampirkannya dalam tanda kutip.
1. Verifikasi bahwa ruang kunci Anda telah dibuat.
```
SELECT * from system_schema.keyspaces;
```
Output dari perintah ini akan terlihat mirip dengan ini.
```
cqlsh> SELECT * from system_schema.keyspaces;
keyspace_name | durable_writes | replication
-------------------------+----------------+-------------------------------------------------------------------------------------
system_schema | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_schema_mcs | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_multiregion_info | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
catalog | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
(5 rows)
```
## Menggunakan AWS CLI
Prosedur berikut membuat keyspace menggunakan file. AWS CLI
**Untuk membuat keyspace menggunakan AWS CLI**
1. Untuk mengonfirmasi bahwa lingkungan Anda sudah diatur, Anda dapat menjalankan perintah berikut di CloudShell.
```
aws keyspaces help
```
1. Buat ruang kunci Anda menggunakan AWS CLI pernyataan berikut.
```
aws keyspaces create-keyspace --keyspace-name 'catalog'
```
1. Verifikasi bahwa ruang kunci Anda dibuat dengan pernyataan berikut AWS CLI
```
aws keyspaces get-keyspace --keyspace-name 'catalog'
```
Output dari perintah ini akan terlihat mirip dengan contoh ini.
```
{
"keyspaceName": "catalog",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/",
"replicationStrategy": "SINGLE_REGION"
}
```
# Periksa status pembuatan keyspace di Amazon Keyspaces
Amazon Keyspaces melakukan operasi data definition language (DDL), seperti membuat dan menghapus keyspaces, secara asinkron.
Anda dapat memantau status pembuatan ruang kunci baru di Konsol Manajemen AWS, yang menunjukkan kapan ruang kunci tertunda atau aktif. Anda juga dapat memantau status pembuatan keyspace baru secara terprogram dengan menggunakan keyspace. `system_schema_mcs` Sebuah keyspace menjadi terlihat dalam `system_schema_mcs` `keyspaces` tabel ketika sudah siap untuk digunakan.
Pola desain yang disarankan untuk memeriksa kapan ruang kunci baru siap digunakan adalah dengan melakukan polling tabel Amazon `system_schema_mcs` `keyspaces` Keyspaces (system\$1schema\$1mcs.\$1). Untuk daftar pernyataan DDL untuk ruang kunci, lihat [Keyspaces](cql.ddl.keyspace.md) bagian dalam referensi bahasa CQL.
Kueri berikut menunjukkan apakah keyspace telah berhasil dibuat.
```
SELECT * FROM system_schema_mcs.keyspaces WHERE keyspace_name = 'mykeyspace';
```
Untuk keyspace yang telah berhasil dibuat, output dari query terlihat seperti berikut.
```
keyspace_name | durable_writes | replication
--------------+-----------------+--------------
mykeyspace | true |{...} 1 item
```
# Buat tabel di Amazon Keyspaces
Di bagian ini, Anda membuat tabel menggunakan konsol,`cqlsh`, atau AWS CLI.
Tabel adalah tempat data Anda diatur dan disimpan. Kunci utama tabel Anda menentukan bagaimana data dipartisi dalam tabel Anda. Kunci utama terdiri dari kunci partisi yang diperlukan dan satu atau lebih kolom pengelompokan opsional. Nilai gabungan yang menyusun kunci utama harus unik di semua data tabel. Untuk informasi selengkapnya tentang tabel, lihat topik berikut:
+ Desain kunci partisi: [Cara menggunakan kunci partisi secara efektif di Amazon Keyspaces](bp-partition-key-design.md)
+ Bekerja dengan tabel: [Periksa status pembuatan tabel di Amazon Keyspaces](tables-create.md)
+ Pernyataan DDL dalam referensi bahasa CQL: [Tabel](cql.ddl.table.md)
+ Manajemen sumber daya tabel: [Mengelola sumber daya tanpa server di Amazon Keyspaces (untuk Apache Cassandra)](serverless_resource_management.md)
+ Pemantauan pemanfaatan sumber daya tabel: [Memantau Amazon Keyspaces dengan Amazon CloudWatch](monitoring-cloudwatch.md)
+ [Kuota untuk Amazon Keyspaces (untuk Apache Cassandra)](quotas.md)
Saat Anda membuat tabel, Anda menentukan yang berikut:
+ Nama tabel.
+ Nama dan tipe data dari setiap kolom dalam tabel.
+ Kunci utama untuk tabel.
+ **Kunci partisi** - Diperlukan
+ **Kolom pengelompokan** - Opsional
Gunakan prosedur berikut untuk membuat tabel dengan kolom tertentu, tipe data, kunci partisi, dan kolom pengelompokan.
## Menggunakan konsol
Prosedur berikut membuat tabel `book_awards` dengan kolom dan tipe data ini.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Untuk membuat tabel menggunakan konsol**
1. [Masuk ke Konsol Manajemen AWS, dan buka konsol Amazon Keyspaces di https://console.aws.amazon.com/keyspaces/ rumah.](https://console.aws.amazon.com/keyspaces/home)
1. Di panel navigasi, pilih **Keyspaces**.
1. Pilih `catalog` sebagai ruang kunci tempat Anda ingin membuat tabel ini.
1. Pilih **Buat tabel**.
1. Di kotak **Nama tabel**, masukkan **book\$1awards** sebagai nama untuk tabel Anda.
**Kendala nama:**
+ Nama tidak bisa kosong.
+ Karakter yang diizinkan: karakter alfanumerik dan garis bawah (). `_`
+ Panjang maksimum adalah 48 karakter.
1. Di bagian **Kolom**, ulangi langkah-langkah berikut untuk setiap kolom yang ingin Anda tambahkan ke tabel ini.
Tambahkan kolom dan tipe data berikut.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
1. **Nama** — Masukkan nama untuk kolom.
**Kendala nama:**
+ Nama tidak bisa kosong.
+ Karakter yang diizinkan: karakter alfanumerik dan garis bawah (). `_`
+ Panjang maksimum adalah 48 karakter.
1. **Jenis** - Dalam daftar tipe data, pilih tipe data untuk kolom ini.
1. Untuk menambahkan kolom lain, pilih **Tambahkan kolom**.
1. Pilih `award` dan `year` sebagai tombol partisi di bawah **Partition Key**. Kunci partisi diperlukan untuk setiap tabel. Kunci partisi dapat dibuat dari satu atau lebih kolom.
1. Tambahkan `category` dan `rank` sebagai **kolom Clustering**. Kolom pengelompokan bersifat opsional dan menentukan urutan pengurutan dalam setiap partisi.
1. Untuk menambahkan kolom pengelompokan, pilih **Tambahkan kolom pengelompokan**.
1. Dalam daftar **Kolom**, pilih **kategori**. Dalam daftar **Urutan**, pilih **ASC** untuk mengurutkan dalam urutan menaik pada nilai di kolom ini. (Pilih **DESC** untuk urutan menurun.)
1. Kemudian pilih **Tambahkan kolom pengelompokan** dan pilih **peringkat**.
1. Di bagian **Pengaturan tabel**, pilih **Pengaturan default**.
1. Pilih **Buat tabel**.
1. Verifikasi bahwa tabel Anda telah dibuat.
1. Di panel navigasi, pilih **Tabel**.
1. Konfirmasikan bahwa tabel Anda ada dalam daftar tabel.
1. Pilih nama meja Anda.
1. Konfirmasikan bahwa semua kolom dan tipe data Anda sudah benar.
**catatan**
Kolom mungkin tidak tercantum dalam urutan yang sama dengan yang Anda tambahkan ke tabel.
## Menggunakan CQL
Prosedur ini membuat tabel dengan kolom dan tipe data berikut menggunakan CQL. `award`Kolom `year` dan adalah kunci partisi dengan `category` dan `rank` sebagai kolom pengelompokan, bersama-sama mereka membentuk kunci utama tabel.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Untuk membuat tabel menggunakan CQL**
1. Buka AWS CloudShell dan sambungkan ke Amazon Keyspaces menggunakan perintah berikut. Pastikan untuk memperbarui *us-east-1* dengan Wilayah Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Output dari perintah itu akan terlihat seperti ini.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
```
1. Pada prompt keyspace (`cqlsh:keyspace_name>`), buat tabel Anda dengan memasukkan kode berikut ke jendela perintah Anda.
```
CREATE TABLE catalog.book_awards (
year int,
award text,
rank int,
category text,
book_title text,
author text,
publisher text,
PRIMARY KEY ((year, award), category, rank)
);
```
**catatan**
`ASC`adalah urutan pengelompokan default. Anda juga dapat menentukan `DESC` urutan menurun.
Perhatikan bahwa `year` dan `award` adalah kolom kunci partisi. Kemudian, `category` dan `rank` adalah kolom pengelompokan yang diurutkan berdasarkan urutan naik ()`ASC`. Bersama-sama, kolom-kolom ini membentuk kunci utama tabel.
1. Verifikasi bahwa tabel Anda telah dibuat.
```
SELECT * from system_schema.tables WHERE keyspace_name='catalog.book_awards' ;
```
Outputnya akan terlihat mirip dengan ini.
```
keyspace_name | table_name | bloom_filter_fp_chance | caching | cdc | comment | compaction | compression | crc_check_chance | dclocal_read_repair_chance | default_time_to_live | extensions | flags | gc_grace_seconds | id | max_index_interval | memtable_flush_period_in_ms | min_index_interval | read_repair_chance | speculative_retry
---------------+------------+------------------------+---------+-----+---------+------------+-------------+------------------+----------------------------+----------------------+------------+-------+------------------+----+--------------------+-----------------------------+--------------------+--------------------+-------------------
(0 rows)
```
1. Verifikasi struktur tabel Anda.
```
SELECT * FROM system_schema.columns WHERE keyspace_name = 'catalog' AND table_name = 'book_awards';
```
Output dari pernyataan ini akan terlihat mirip dengan contoh ini.
```
keyspace_name | table_name | column_name | clustering_order | column_name_bytes | kind | position | type
---------------+-------------+-------------+------------------+------------------------+---------------+----------+------
catalog | book_awards | year | none | 0x79656172 | partition_key | 0 | int
catalog | book_awards | award | none | 0x6177617264 | partition_key | 1 | text
catalog | book_awards | category | asc | 0x63617465676f7279 | clustering | 0 | text
catalog | book_awards | rank | asc | 0x72616e6b | clustering | 1 | int
catalog | book_awards | author | none | 0x617574686f72 | regular | -1 | text
catalog | book_awards | book_title | none | 0x626f6f6b5f7469746c65 | regular | -1 | text
catalog | book_awards | publisher | none | 0x7075626c6973686572 | regular | -1 | text
(7 rows)
```
Konfirmasikan bahwa semua kolom dan tipe data seperti yang Anda harapkan. Urutan kolom mungkin berbeda dari pada `CREATE` pernyataan.
## Menggunakan AWS CLI
Prosedur ini membuat tabel dengan kolom dan tipe data berikut menggunakan AWS CLI. `award`Kolom `year` dan membentuk kunci partisi dengan `category` dan `rank` sebagai kolom pengelompokan.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Untuk membuat tabel menggunakan AWS CLI**
Perintah berikut membuat tabel dengan nama *book\$1awards*. Kunci partisi tabel terdiri dari kolom `year` dan `award` dan kunci pengelompokan terdiri dari kolom `category` dan`rank`, kedua kolom pengelompokan menggunakan urutan urutan menaik. (Untuk memudahkan pembacaan, perintah tabel buat di bagian ini dipecah menjadi baris terpisah.) `schema-definition`
1. Anda dapat membuat tabel menggunakan pernyataan berikut.
```
aws keyspaces create-table --keyspace-name 'catalog' \
--table-name 'book_awards' \
--schema-definition 'allColumns=[{name=year,type=int},{name=award,type=text},{name=rank,type=int},
{name=category,type=text}, {name=author,type=text},{name=book_title,type=text},{name=publisher,type=text}],
partitionKeys=[{name=year},{name=award}],clusteringKeys=[{name=category,orderBy=ASC},{name=rank,orderBy=ASC}]'
```
Perintah ini menghasilkan output berikut.
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards"
}
```
1. Untuk mengonfirmasi metadata dan properti tabel, Anda dapat menggunakan perintah berikut.
```
aws keyspaces get-table --keyspace-name 'catalog' --table-name 'book_awards'
```
Perintah ini mengembalikan output berikut.
```
{
"keyspaceName": "catalog",
"tableName": "book_awards",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards",
"creationTimestamp": "2024-07-11T15:12:55.571000+00:00",
"status": "ACTIVE",
"schemaDefinition": {
"allColumns": [
{
"name": "year",
"type": "int"
},
{
"name": "award",
"type": "text"
},
{
"name": "category",
"type": "text"
},
{
"name": "rank",
"type": "int"
},
{
"name": "author",
"type": "text"
},
{
"name": "book_title",
"type": "text"
},
{
"name": "publisher",
"type": "text"
}
],
"partitionKeys": [
{
"name": "year"
},
{
"name": "award"
}
],
"clusteringKeys": [
{
"name": "category",
"orderBy": "ASC"
},
{
"name": "rank",
"orderBy": "ASC"
}
],
"staticColumns": []
},
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2024-07-11T15:12:55.571000+00:00"
},
"encryptionSpecification": {
"type": "AWS_OWNED_KMS_KEY"
},
"pointInTimeRecovery": {
"status": "DISABLED"
},
"defaultTimeToLive": 0,
"comment": {
"message": ""
},
"replicaSpecifications": []
}
```
Untuk melakukan operasi CRUD (membuat, membaca, memperbarui, dan menghapus) pada data dalam tabel Anda, lanjutkan ke[Membuat, membaca, memperbarui, dan menghapus data (CRUD) menggunakan CQL di Amazon Keyspaces](getting-started.dml.md).
# Periksa status pembuatan tabel di Amazon Keyspaces
Amazon Keyspaces melakukan operasi data definition language (DDL), seperti membuat dan menghapus tabel, secara asinkron. Anda dapat memantau status pembuatan tabel baru di Konsol Manajemen AWS, yang menunjukkan kapan tabel tertunda atau aktif. Anda juga dapat memantau status pembuatan tabel baru secara terprogram dengan menggunakan tabel skema sistem.
Sebuah tabel menunjukkan sebagai aktif dalam skema sistem ketika siap untuk digunakan. Pola desain yang disarankan untuk memeriksa kapan tabel baru siap digunakan adalah dengan melakukan polling tabel skema sistem Amazon Keyspaces (). `system_schema_mcs.*` Untuk daftar pernyataan DDL untuk tabel, lihat [Tabel](cql.ddl.table.md) bagian dalam referensi bahasa CQL.
Query berikut menunjukkan status tabel.
```
SELECT keyspace_name, table_name, status FROM system_schema_mcs.tables WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Untuk tabel yang masih dibuat dan tertunda, output kueri terlihat seperti ini.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | CREATING
```
Untuk tabel yang telah berhasil dibuat dan aktif, output dari query terlihat seperti berikut.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | ACTIVE
```
# Membuat, membaca, memperbarui, dan menghapus data (CRUD) menggunakan CQL di Amazon Keyspaces
Pada langkah tutorial ini, Anda akan belajar cara menyisipkan, membaca, memperbarui, dan menghapus data dalam tabel Amazon Keyspaces menggunakan pernyataan CQL data manipulation language (DHTML). Di Amazon Keyspaces, Anda hanya dapat membuat pernyataan DHTML dalam bahasa CQL. Dalam tutorial ini, Anda akan berlatih menjalankan pernyataan DHTML menggunakan `cqlsh-expansion` with [AWS CloudShell](using-aws-with-cloudshell.md)di. Konsol Manajemen AWS
+ **Menyisipkan data** - Bagian ini mencakup penyisipan catatan tunggal dan beberapa ke dalam tabel menggunakan pernyataan. `INSERT` Anda akan mempelajari cara mengunggah data dari file CSV dan memverifikasi sisipan yang berhasil menggunakan `SELECT` kueri.
+ **Membaca data** — Di sini, Anda akan menjelajahi berbagai variasi `SELECT` pernyataan untuk mengambil data dari tabel. Topik termasuk memilih semua data, memilih kolom tertentu, memfilter baris berdasarkan kondisi menggunakan `WHERE` klausa, dan memahami kondisi sederhana dan gabungan.
+ **Memperbarui data** — Di bagian ini, Anda akan mempelajari cara memodifikasi data yang ada dalam tabel menggunakan `UPDATE` pernyataan. Anda akan berlatih memperbarui kolom tunggal dan beberapa sambil memahami batasan seputar memperbarui kolom kunci utama.
+ **Menghapus data** — Bagian terakhir mencakup penghapusan data dari tabel menggunakan pernyataan. `DELETE` Anda akan belajar cara menghapus sel tertentu, seluruh baris, dan implikasi menghapus data versus menghapus seluruh tabel atau ruang kunci.
Sepanjang tutorial, Anda akan menemukan contoh, tips, dan kesempatan untuk berlatih menulis kueri CQL Anda sendiri untuk berbagai skenario.
**Topics**
+ [Memasukkan dan memuat data ke dalam tabel Amazon Keyspaces](getting-started.dml.create.md)
+ [Membaca data dari tabel menggunakan `SELECT` pernyataan CQL di Amazon Keyspaces](getting-started.dml.read.md)
+ [Perbarui data dalam tabel Amazon Keyspaces menggunakan CQL](getting-started.dml.update.md)
+ [Hapus data dari tabel menggunakan pernyataan `DELETE` CQL](getting-started.dml.delete.md)
# Memasukkan dan memuat data ke dalam tabel Amazon Keyspaces
Untuk membuat data dalam `book_awards` tabel Anda, gunakan `INSERT` pernyataan untuk menambahkan satu baris.
1. Buka AWS CloudShell dan sambungkan ke Amazon Keyspaces menggunakan perintah berikut. Pastikan untuk memperbarui *us-east-1* dengan Wilayah Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Output dari perintah itu akan terlihat seperti ini.
```
Connected to Amazon Keyspaces at cassandra.us-east-1.amazonaws.com:9142
[cqlsh 6.1.0 | Cassandra 3.11.2 | CQL spec 3.4.4 | Native protocol v4]
Use HELP for help.
cqlsh current consistency level is ONE.
```
1. Sebelum Anda dapat menulis data ke tabel Amazon Keyspaces menggunakan cqlsh, Anda harus mengatur konsistensi tulis untuk sesi cqlsh saat ini. `LOCAL_QUORUM` Untuk informasi selengkapnya tentang tingkat konsistensi yang didukung, lihat[Tulis tingkat konsistensi](consistency.md#WriteConsistency). Perhatikan bahwa langkah ini tidak diperlukan jika Anda menggunakan editor CQL di. Konsol Manajemen AWS
```
CONSISTENCY LOCAL_QUORUM;
```
1. Untuk menyisipkan satu catatan, jalankan perintah berikut di editor CQL.
```
INSERT INTO catalog.book_awards (award, year, category, rank, author, book_title, publisher)
VALUES ('Wolf', 2023, 'Fiction',3,'Shirley Rodriguez','Mountain', 'AnyPublisher') ;
```
1. Verifikasi bahwa data telah ditambahkan dengan benar ke tabel Anda dengan menjalankan perintah berikut.
```
SELECT * FROM catalog.book_awards;
```
Output dari pernyataan akan terlihat seperti ini.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+-------------------+------------+--------------
2023 | Wolf | Fiction | 3 | Shirley Rodriguez | Mountain | AnyPublisher
(1 rows)
```
**Untuk menyisipkan beberapa catatan dari file menggunakan cqlsh**
1. Unduh contoh file CSV (`keyspaces_sample_table.csv`) yang terkandung dalam file arsip [samplemigration.zip](samples/samplemigration.zip). Buka zip arsip dan catat jalur ke`keyspaces_sample_table.csv`.
![\[Tangkapan layar file CSV yang menunjukkan output tabel setelah mengimpor file csv.\]](http://docs.aws.amazon.com/id_id/keyspaces/latest/devguide/images/keyspaces-awards.png)
1. Buka AWS CloudShell di Konsol Manajemen AWS dan sambungkan ke Amazon Keyspaces menggunakan perintah berikut. Pastikan untuk memperbarui *us-east-1* dengan Wilayah Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Pada `cqlsh` prompt (`cqlsh>`), tentukan ruang kunci.
```
USE catalog ;
```
1. Tetapkan konsistensi tulis ke`LOCAL_QUORUM`. Untuk informasi selengkapnya tentang tingkat konsistensi yang didukung, lihat[Tulis tingkat konsistensi](consistency.md#WriteConsistency).
```
CONSISTENCY LOCAL_QUORUM;
```
1. Dalam AWS CloudShell pilih **Tindakan** di sisi kanan atas layar dan kemudian pilih **Unggah file untuk mengunggah file** csv yang diunduh sebelumnya. Catat jalur ke file.
1. Pada prompt keyspace (`cqlsh:catalog>`), jalankan pernyataan berikut.
```
COPY book_awards (award, year, category, rank, author, book_title, publisher) FROM '/home/cloudshell-user/keyspaces_sample_table.csv' WITH header=TRUE ;
```
Output dari pernyataan harus terlihat mirip dengan ini.
```
cqlsh:catalog> COPY book_awards (award, year, category, rank, author, book_title, publisher) FROM '/home/cloudshell-user/keyspaces_sample_table.csv' WITH delimiter=',' AND header=TRUE ;
cqlsh current consistency level is LOCAL_QUORUM.
Reading options from /home/cloudshell-user/.cassandra/cqlshrc:[copy]: {'numprocesses': '16', 'maxattempts': '1000'}
Reading options from /home/cloudshell-user/.cassandra/cqlshrc:[copy-from]: {'ingestrate': '1500', 'maxparseerrors': '1000', 'maxinserterrors': '-1', 'maxbatchsize': '10', 'minbatchsize': '1', 'chunksize': '30'}
Reading options from the command line: {'delimiter': ',', 'header': 'TRUE'}
Using 16 child processes
Starting copy of catalog.book_awards with columns [award, year, category, rank, author, book_title, publisher].
OSError: handle is closed 0 rows/s; Avg. rate: 0 rows/s
Processed: 9 rows; Rate: 0 rows/s; Avg. rate: 0 rows/s
9 rows imported from 1 files in 0 day, 0 hour, 0 minute, and 26.706 seconds (0 skipped).
```
1. Verifikasi bahwa data telah ditambahkan dengan benar ke tabel Anda dengan menjalankan kueri berikut.
```
SELECT * FROM book_awards ;
```
Anda akan melihat output berikut.
```
year | award | category | rank | author | book_title | publisher
------+------------------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | Example Books
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
2020 | Kwesi Manu Prize | Fiction | 1 | Akua Mansa | Where did you go? | SomePublisher
2020 | Kwesi Manu Prize | Fiction | 2 | John Stiles | Yesterday | Example Books
2020 | Kwesi Manu Prize | Fiction | 3 | Nikki Wolf | Moving to the Chateau | AnyPublisher
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | Long Summer | SomePublisher
2020 | Richard Roe | Fiction | 2 | Arnav Desai | The Key | Example Books
2020 | Richard Roe | Fiction | 3 | Mateo Jackson | Inside the Whale | AnyPublisher
(9 rows)
```
Untuk mempelajari lebih lanjut tentang cara `cqlsh COPY` mengunggah data dari file csv ke tabel Amazon Keyspaces, lihat. [Tutorial: Memuat data ke Amazon Keyspaces menggunakan cqlsh](bulk-upload.md)
# Membaca data dari tabel menggunakan `SELECT` pernyataan CQL di Amazon Keyspaces
Di [Memasukkan dan memuat data ke dalam tabel Amazon Keyspaces](getting-started.dml.create.md) bagian ini, Anda menggunakan `SELECT` pernyataan untuk memverifikasi bahwa Anda telah berhasil menambahkan data ke tabel Anda. Di bagian ini, Anda menyempurnakan penggunaan `SELECT` untuk menampilkan kolom tertentu, dan hanya baris yang memenuhi kriteria tertentu.
Bentuk umum `SELECT` pernyataan tersebut adalah sebagai berikut.
```
SELECT column_list FROM table_name [WHERE condition [ALLOW FILTERING]] ;
```
**Topics**
+ [Pilih semua data di tabel Anda](#getting-started.dml.read.all)
+ [Pilih subset kolom](#getting-started.dml.read.columns)
+ [Pilih subset baris](#getting-started.dml.read.rows)
## Pilih semua data di tabel Anda
Bentuk paling sederhana dari `SELECT` pernyataan mengembalikan semua data dalam tabel Anda.
**penting**
Dalam lingkungan produksi, biasanya bukan praktik terbaik untuk menjalankan perintah ini, karena ia mengembalikan semua data dalam tabel Anda.
**Untuk memilih semua data tabel**
1. Buka AWS CloudShell dan sambungkan ke Amazon Keyspaces menggunakan perintah berikut. Pastikan untuk memperbarui *us-east-1* dengan Wilayah Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Jalankan query berikut.
```
SELECT * FROM catalog.book_awards ;
```
Menggunakan karakter wild-card (`*`) untuk `column_list` memilih semua kolom. Output dari pernyataan terlihat seperti contoh berikut.
```
year | award | category | rank | author | book_title | publisher
------+------------------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | AnyPublisher
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
2020 | Kwesi Manu Prize | Fiction | 1 | Akua Mansa | Where did you go? | SomePublisher
2020 | Kwesi Manu Prize | Fiction | 2 | John Stiles | Yesterday | Example Books
2020 | Kwesi Manu Prize | Fiction | 3 | Nikki Wolf | Moving to the Chateau | AnyPublisher
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | Long Summer | SomePublisher
2020 | Richard Roe | Fiction | 2 | Arnav Desai | The Key | Example Books
2020 | Richard Roe | Fiction | 3 | Mateo Jackson | Inside the Whale | AnyPublisher
```
## Pilih subset kolom
**Untuk menanyakan subset kolom**
1. Buka AWS CloudShell dan sambungkan ke Amazon Keyspaces menggunakan perintah berikut. Pastikan untuk memperbarui *us-east-1* dengan Wilayah Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Untuk mengambil hanya`award`,`category`, dan `year` kolom, jalankan query berikut.
```
SELECT award, category, year FROM catalog.book_awards ;
```
Output hanya berisi kolom yang ditentukan dalam urutan yang tercantum dalam `SELECT` pernyataan.
```
award | category | year
------------------+-------------+------
Wolf | Non-Fiction | 2020
Wolf | Non-Fiction | 2020
Wolf | Non-Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Kwesi Manu Prize | Fiction | 2020
Richard Roe | Fiction | 2020
Richard Roe | Fiction | 2020
Richard Roe | Fiction | 2020
```
## Pilih subset baris
Saat menanyakan kumpulan data besar, Anda mungkin hanya menginginkan catatan yang memenuhi kriteria tertentu. Untuk melakukan ini, Anda dapat menambahkan `WHERE` klausa ke akhir pernyataan kami`SELECT`.
**Untuk menanyakan subset baris**
1. Buka AWS CloudShell dan sambungkan ke Amazon Keyspaces menggunakan perintah berikut. Pastikan untuk memperbarui *us-east-1* dengan Wilayah Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Untuk mengambil hanya catatan untuk penghargaan tahun tertentu, jalankan kueri berikut.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Wolf' ;
```
`SELECT`Pernyataan sebelumnya mengembalikan output berikut.
```
year | award | category | rank | author | book_title | publisher
------+-------+-------------+------+--------------------+-----------------------+---------------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | AnyPublisher
2020 | Wolf | Non-Fiction | 2 | Ana Carolina Silva | Science Today | SomePublisher
2020 | Wolf | Non-Fiction | 3 | Shirley Rodriguez | The Future of Sea Ice | AnyPublisher
```
### Memahami `WHERE` klausa
`WHERE`Klausul ini digunakan untuk memfilter data dan hanya mengembalikan data yang memenuhi kriteria yang ditentukan. Kriteria yang ditentukan dapat berupa kondisi sederhana atau kondisi majemuk.
**Cara menggunakan kondisi dalam `WHERE` klausa**
+ Kondisi sederhana - Satu kolom.
```
WHERE column_name=value
```
Anda dapat menggunakan kondisi sederhana dalam `WHERE` klausa jika salah satu dari kondisi berikut terpenuhi:
+ Kolom adalah satu-satunya kolom kunci partisi dari tabel.
+ Anda menambahkan `ALLOW FILTERING` setelah kondisi dalam `WHERE` klausa.
Ketahuilah bahwa penggunaan `ALLOW FILTERING` dapat menghasilkan kinerja yang tidak konsisten, terutama dengan tabel besar dan multi-partisi.
+ Kondisi majemuk — Beberapa kondisi sederhana yang dihubungkan oleh`AND`.
```
WHERE column_name1=value1 AND column_name2=value2 AND column_name3=value3...
```
Anda dapat menggunakan kondisi majemuk dalam `WHERE` klausa jika salah satu dari kondisi berikut terpenuhi:
+ Kolom yang dapat Anda gunakan dalam `WHERE` klausa harus menyertakan semua atau subset kolom dalam kunci partisi tabel. Jika Anda ingin menggunakan hanya subset kolom dalam `WHERE` klausa, Anda harus menyertakan satu set kolom kunci partisi yang berdekatan dari kiri ke kanan, dimulai dengan kolom utama kunci partisi. Misalnya, jika kolom kunci partisi adalah`year`,`month`, dan `award` kemudian Anda dapat menggunakan kolom berikut dalam `WHERE` klausa:
+ `year`
+ `year`DAN `month`
+ `year``month`DAN `award`
+ Anda menambahkan `ALLOW FILTERING` setelah kondisi majemuk dalam `WHERE` klausa, seperti pada contoh berikut.
```
SELECT * FROM my_table WHERE col1=5 AND col2='Bob' ALLOW FILTERING ;
```
Ketahuilah bahwa penggunaan `ALLOW FILTERING` dapat menghasilkan kinerja yang tidak konsisten, terutama dengan tabel besar dan multi-partisi.
### Cobalah
Buat kueri CQL Anda sendiri untuk menemukan yang berikut dari tabel Anda: `book_awards`
+ Temukan pemenang penghargaan Wolf 2020 dan tampilkan judul buku dan penulis, diurutkan berdasarkan peringkat.
+ Tunjukkan pemenang hadiah pertama untuk semua penghargaan pada tahun 2020 dan tampilkan judul buku dan nama penghargaan.
# Perbarui data dalam tabel Amazon Keyspaces menggunakan CQL
Untuk memperbarui data dalam `book_awards` tabel Anda, gunakan `UPDATE` pernyataan.
Bentuk umum `UPDATE` pernyataan tersebut adalah sebagai berikut.
```
UPDATE table_name SET column_name=new_value WHERE primary_key=value ;
```
**Tip**
Anda dapat memperbarui beberapa kolom dengan menggunakan daftar `column_names` dan nilai yang dipisahkan koma, seperti pada contoh berikut.
```
UPDATE my_table SET col1='new_value_1', col2='new_value2' WHERE col3='1' ;
```
Jika kunci primer terdiri dari beberapa kolom, semua kolom kunci primer dan nilainya harus disertakan dalam `WHERE` klausa.
Anda tidak dapat memperbarui kolom apa pun di kunci utama karena itu akan mengubah kunci utama untuk catatan.
**Untuk memperbarui satu sel**
Menggunakan `book_awards` meja Anda, ubah nama penerbit untuk pemenang penghargaan Wolf non-fiksi pada tahun 2020.
```
UPDATE book_awards SET publisher='new Books' WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
Verifikasi bahwa penerbit sekarang`new Books`.
```
SELECT * FROM book_awards WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
Pernyataan harus mengembalikan output berikut.
```
year | award | category | rank | author | book_title | publisher
------+-------+-------------+------+-------------+------------------+-----------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | new Books
```
## Cobalah
**Lanjutan:** Pemenang fiksi 2020 “Kwezi Manu Prize” telah mengubah nama mereka. Perbarui catatan ini untuk mengubah nama menjadi`'Akua Mansa-House'`.
# Hapus data dari tabel menggunakan pernyataan `DELETE` CQL
Untuk menghapus data dalam `book_awards` tabel Anda, gunakan `DELETE` pernyataan.
Anda dapat menghapus data dari baris atau dari partisi. Hati-hati saat menghapus data, karena penghapusan tidak dapat diubah.
Menghapus satu atau semua baris dari tabel tidak menghapus tabel. Dengan demikian Anda dapat mengisinya kembali dengan data. Menghapus tabel akan menghapus tabel dan semua data di dalamnya. Untuk menggunakan tabel lagi, Anda harus membuatnya kembali dan menambahkan data ke dalamnya. Menghapus keyspace akan menghapus keyspace dan semua tabel di dalamnya. Untuk menggunakan keyspace dan tabel, Anda harus membuatnya kembali, dan kemudian mengisinya dengan data. Anda dapat menggunakan pemulihan Amazon Keyspaces Point-in-time (PITR) untuk membantu memulihkan tabel yang dihapus, untuk mempelajari selengkapnya lihat. [Cadangkan dan pulihkan data dengan point-in-time pemulihan untuk Amazon Keyspaces](PointInTimeRecovery.md) Untuk mempelajari cara mengembalikan tabel yang dihapus dengan PITR diaktifkan, lihat[Kembalikan tabel yang dihapus menggunakan Amazon Keyspaces PITR](restoredeleted.md).
## Hapus sel
Menghapus kolom dari baris menghapus data dari sel yang ditentukan. Saat Anda menampilkan kolom itu menggunakan `SELECT` pernyataan, data ditampilkan sebagai*null*, meskipun nilai null tidak disimpan di lokasi tersebut.
Sintaks umum untuk menghapus satu atau lebih kolom spesifik adalah sebagai berikut.
```
DELETE column_name1[, column_name2...] FROM table_name WHERE condition ;
```
Di `book_awards` tabel Anda, Anda dapat melihat bahwa judul buku yang memenangkan harga pertama dari harga “Richard Roe” 2020 adalah “Long Summer”. Bayangkan judul ini telah ditarik kembali, dan Anda perlu menghapus data dari sel ini.
**Untuk menghapus sel tertentu**
1. Buka AWS CloudShell dan sambungkan ke Amazon Keyspaces menggunakan perintah berikut. Pastikan untuk memperbarui *us-east-1* dengan Wilayah Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Jalankan `DELETE` query berikut.
```
DELETE book_title FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Verifikasi bahwa permintaan penghapusan dibuat seperti yang diharapkan.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
Output dari pernyataan ini terlihat seperti ini.
```
year | award | category | rank | author | book_title | publisher
------+-------------+----------+------+-------------------+------------+---------------
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | null | SomePublisher
```
## Hapus baris
Mungkin ada saat ketika Anda perlu menghapus seluruh baris, misalnya untuk memenuhi permintaan penghapusan data. Sintaks umum untuk menghapus baris adalah sebagai berikut.
```
DELETE FROM table_name WHERE condition ;
```
**Untuk menghapus baris**
1. Buka AWS CloudShell dan sambungkan ke Amazon Keyspaces menggunakan perintah berikut. Pastikan untuk memperbarui *us-east-1* dengan Wilayah Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Jalankan `DELETE` query berikut.
```
DELETE FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Verifikasi bahwa penghapusan dilakukan seperti yang diharapkan.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
Output dari pernyataan ini terlihat seperti ini setelah baris telah dihapus.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+--------+------------+-----------
(0 rows)
```
Anda dapat menghapus data kedaluwarsa secara otomatis dari tabel menggunakan Amazon Keyspaces Time to Live, untuk informasi selengkapnya, lihat. [Data kedaluwarsa dengan Time to Live (TTL) untuk Amazon Keyspaces (untuk Apache Cassandra)](TTL.md)
# Hapus tabel di Amazon Keyspaces
Untuk menghindari biaya untuk tabel dan data yang tidak Anda butuhkan, hapus semua tabel yang tidak Anda gunakan. Saat Anda menghapus tabel, tabel dan datanya akan dihapus dan Anda berhenti mengeluarkan biaya untuk mereka. Namun, ruang kunci tetap ada. Saat Anda menghapus ruang kunci, ruang kunci dan semua tabelnya dihapus dan Anda berhenti menambah biaya untuk mereka.
Anda dapat menghapus tabel menggunakan konsol, CQL, atau file. AWS CLI Saat Anda menghapus tabel, tabel dan semua datanya akan dihapus.
## Menggunakan konsol
Prosedur berikut menghapus tabel dan semua datanya menggunakan file. Konsol Manajemen AWS
**Untuk menghapus tabel menggunakan konsol**
1. [Masuk ke Konsol Manajemen AWS, dan buka konsol Amazon Keyspaces di https://console.aws.amazon.com/keyspaces/ rumah.](https://console.aws.amazon.com/keyspaces/home)
1. Di panel navigasi, pilih **Tabel**.
1. Pilih kotak di sebelah kiri nama setiap tabel yang ingin Anda hapus.
1. Pilih **Hapus**.
1. Pada layar **Hapus tabel**, masukkan **Delete** di dalam kotak. Kemudian, pilih **Hapus tabel**.
1. Untuk memverifikasi bahwa tabel telah dihapus, pilih **Tabel** di panel navigasi, dan konfirmasikan bahwa `book_awards` tabel tidak lagi terdaftar.
## Menggunakan CQL
Prosedur berikut menghapus tabel dan semua datanya menggunakan CQL.
**Untuk menghapus tabel menggunakan CQL**
1. Buka AWS CloudShell dan sambungkan ke Amazon Keyspaces menggunakan perintah berikut. Pastikan untuk memperbarui *us-east-1* dengan Wilayah Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Hapus tabel Anda dengan memasukkan pernyataan berikut.
```
DROP TABLE IF EXISTS catalog.book_awards ;
```
1. Verifikasi bahwa tabel Anda telah dihapus.
```
SELECT * FROM system_schema.tables WHERE keyspace_name = 'catalog' ;
```
Outputnya akan terlihat seperti ini. Perhatikan bahwa ini mungkin memakan waktu, jadi jalankan kembali pernyataan setelah satu menit jika Anda tidak melihat hasil ini.
```
keyspace_name | table_name | bloom_filter_fp_chance | caching | cdc | comment | compaction | compression | crc_check_chance | dclocal_read_repair_chance | default_time_to_live | extensions | flags | gc_grace_seconds | id | max_index_interval | memtable_flush_period_in_ms | min_index_interval | read_repair_chance | speculative_retry
---------------+------------+------------------------+---------+-----+---------+------------+-------------+------------------+----------------------------+----------------------+------------+-------+------------------+----+--------------------+-----------------------------+--------------------+--------------------+-------------------
(0 rows)
```
## Menggunakan AWS CLI
Prosedur berikut menghapus tabel dan semua datanya menggunakan file. AWS CLI
**Untuk menghapus tabel menggunakan AWS CLI**
1. Buka CloudShell
1. Hapus tabel Anda dengan pernyataan berikut.
```
aws keyspaces delete-table --keyspace-name 'catalog' --table-name 'book_awards'
```
1. Untuk memverifikasi bahwa tabel Anda telah dihapus, Anda dapat mencantumkan semua tabel di ruang kunci.
```
aws keyspaces list-tables --keyspace-name 'catalog'
```
Anda akan melihat output berikut. Perhatikan bahwa operasi asinkron ini dapat memakan waktu. Jalankan kembali perintah lagi setelah beberapa saat untuk mengonfirmasi bahwa tabel telah dihapus.
```
{
"tables": []
}
```
# Hapus ruang kunci di Amazon Keyspaces
Agar tidak dikenakan biaya untuk ruang kunci, hapus semua ruang kunci yang tidak Anda gunakan. Saat Anda menghapus ruang kunci, ruang kunci dan semua tabelnya dihapus dan Anda berhenti menambah biaya untuk mereka.
Anda dapat menghapus ruang kunci menggunakan konsol, CQL, atau. AWS CLI
## Menggunakan konsol
Prosedur berikut menghapus keyspace dan semua tabel dan datanya menggunakan konsol.
**Untuk menghapus ruang kunci menggunakan konsol**
1. [Masuk ke Konsol Manajemen AWS, dan buka konsol Amazon Keyspaces di https://console.aws.amazon.com/keyspaces/ rumah.](https://console.aws.amazon.com/keyspaces/home)
1. Di panel navigasi, pilih **Keyspaces**.
1. Pilih kotak di sebelah kiri nama setiap ruang tombol yang ingin Anda hapus.
1. Pilih **Hapus**.
1. Pada layar **Delete keyspace**, masukkan **Delete** di dalam kotak. Kemudian, pilih **Hapus ruang kunci**.
1. Untuk memverifikasi bahwa ruang kunci `catalog` telah dihapus, pilih **Keyspaces** di panel navigasi dan konfirmasikan bahwa itu tidak lagi terdaftar. Karena Anda menghapus ruang kuncinya, `book_awards` tabel di bawah **Tabel** juga tidak boleh terdaftar.
## Menggunakan CQL
Prosedur berikut menghapus keyspace dan semua tabel dan data menggunakan CQL.
**Untuk menghapus keyspace menggunakan CQL**
1. Buka AWS CloudShell dan sambungkan ke Amazon Keyspaces menggunakan perintah berikut. Pastikan untuk memperbarui *us-east-1* dengan Wilayah Anda sendiri.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Hapus ruang kunci Anda dengan memasukkan pernyataan berikut.
```
DROP KEYSPACE IF EXISTS catalog ;
```
1. Verifikasi bahwa ruang kunci Anda telah dihapus.
```
SELECT * from system_schema.keyspaces ;
```
Ruang kunci Anda tidak boleh terdaftar. Perhatikan bahwa karena ini adalah operasi asinkron, mungkin ada penundaan hingga ruang kunci dihapus. Setelah keyspace dihapus, output dari pernyataan akan terlihat seperti ini.
```
keyspace_name | durable_writes | replication
-------------------------+----------------+-------------------------------------------------------------------------------------
system_schema | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_schema_mcs | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
system_multiregion_info | True | {'class': 'org.apache.cassandra.locator.SimpleStrategy', 'replication_factor': '3'}
(4 rows)
```
## Menggunakan AWS CLI
Prosedur berikut menghapus keyspace dan semua tabel dan datanya menggunakan file. AWS CLI
**Untuk menghapus ruang kunci menggunakan AWS CLI**
1. Buka AWS CloudShell
1. Hapus ruang kunci Anda dengan memasukkan pernyataan berikut.
```
aws keyspaces delete-keyspace --keyspace-name 'catalog'
```
1. Verifikasi bahwa ruang kunci Anda telah dihapus.
```
aws keyspaces list-keyspaces
```
Output dari pernyataan ini akan terlihat mirip dengan ini, dan hanya daftar keyspaces sistem. Perhatikan bahwa karena ini adalah operasi asinkron, mungkin ada penundaan hingga ruang kunci Anda dihapus.
```
{
"keyspaces": [
{
"keyspaceName": "system_schema",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_schema/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system_schema_mcs",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_schema_mcs/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system/",
"replicationStrategy": "SINGLE_REGION"
},
{
"keyspaceName": "system_multiregion_info",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/system_multiregion_info/",
"replicationStrategy": "SINGLE_REGION"
}
]
}
```