本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# Amazon Keyspaces（Apache Cassandra 兼容）
如果您还不熟悉 Apache Cassandra 和 Amazon Keyspaces，本教程将全程指导您安装可以成功使用 Amazon Keyspaces 所需的程序和工具。你将学习如何使用 Cassandra 查询语言 (CQL) AWS 管理控制台、或 () 创建密钥空间和表。 AWS Command Line Interface AWS CLI然后您可以使用 Cassandra 查询语言（CQL）对 Amazon Keyspaces 表中的数据执行创建、读取、更新和删除（CRUD）操作。
本教程包含以下步骤。
+ **先决条件** — 在开始本教程之前，请按照 AWS 设置说明注册 AWS 并创建有权访问 Amazon Keyspaces 的 IAM 用户。然后设置`cqhsh-expansion`和 AWS CloudShell。或者，您可以使用在 Amazon Keyspaces 中创建资源。 AWS CLI
+ **第 1 步：创建键空间和表** - 在本节中，您将创建一个名为“catalog”的键空间，并在其中创建一个名为“book\$1awards”的表。您将使用、CQL 或来指定表的列、数据类型 AWS 管理控制台、分区键和聚类列。 AWS CLI
+ **第 2 步：执行 CRUD 操作** — 在这里，您将使用输入`cqlsh-expansion`在 CloudShell “book\$1awards” 表中插入、读取、更新和删除数据。您将学习如何使用各种 CQL 语句，例如 SELECT、INSERT、UPDATE 和 DELETE，并练习筛选和修改数据。
+ **第 3 步：清理资源** - 为了避免为未使用的资源支付费用，本节将指导您使用控制台、CQL 或 AWS CLI删除“book\$1awards”表和“catalog”键空间。
有关使用不同 Apache Cassandra 客户端驱动程序以编程方式连接 Amazon Keyspaces 的教程，请参阅[使用 Cassandra 客户端驱动程序以编程方式访问 Amazon Keyspaces](programmatic.drivers.md)。有关使用不同的代码示例 AWS SDKs，请参阅 [Amazon Keyspaces 使用的代码示例](https://docs.aws.amazon.com/keyspaces/latest/devguide/service_code_examples.html)。 AWS SDKs
**Topics**
+ [教程先决条件和注意事项](getting-started.before-you-begin.md)
+ [在 Amazon Keyspaces 中创建键空间](getting-started.keyspaces.md)
+ [在 Amazon Keyspaces 中查看键空间的创建状态](keyspaces-create.md)
+ [在 Amazon Keyspaces 中创建表](getting-started.tables.md)
+ [在 Amazon Keyspaces 中查看表的创建状态](tables-create.md)
+ [在 Amazon Keyspaces 中使用 CQL 创建、读取、更新和删除数据（CRUD）](getting-started.dml.md)
+ [在 Amazon Keyspaces 中删除表](getting-started.clean-up.table.md)
+ [在 Amazon Keyspaces 中删除键空间](getting-started.clean-up.keyspace.md)
# 教程先决条件和注意事项
在开始使用 Amazon Keyspaces 之前，请按照中的 AWS 设置说明进行操作。[访问 Amazon Keyspaces（Apache Cassandra 兼容）](accessing.md)这些步骤包括注册 AWS 和创建有权访问 Amazon Keyspaces 的 AWS Identity and Access Management (IAM) 用户。
要完成本教程的所有步骤，您需要安装 `cqlsh`。您可以遵循[使用 `cqlsh` 连接 Amazon Keyspaces](programmatic.cqlsh.md) 中的说明进行操作。
要使用`cqlsh`或访问 Amazon Keyspaces AWS CLI，我们建议使用。 AWS CloudShell CloudShell是一个基于浏览器、经过预先验证的 shell，您可以直接从启动。 AWS 管理控制台您可以使用首选外壳 AWS Command Line Interface （Bash PowerShell 或 Z shell AWS CLI）对 Amazon Keyspaces 运行 () 命令。要使用 `cqlsh`，必须安装 `cqlsh-expansion`。有关 `cqlsh-expansion` 安装说明，请参阅[使用 `cqlsh-expansion` 连接 Amazon Keyspaces](programmatic.cqlsh.md#using_cqlsh)。有关的更多信息，请参 CloudShell 阅[AWS CloudShell 用于访问 Amazon Keyspaces](using-aws-with-cloudshell.md)。
要使用创建、查看和删除 Amazon Keyspaces 中的资源，请按照中的设置说明进行操作。 AWS CLI [正在下载并配置 AWS CLI](access.cli.md#access.cli.installcli)
完成先决条件步骤后，继续执行[在 Amazon Keyspaces 中创建键空间](getting-started.keyspaces.md)。
# 在 Amazon Keyspaces 中创建键空间
在本部分中，将使用控制台、`cqlsh` 或 AWS CLI创建键空间。
**注意**
开始之前，请确保您已具备所有[教程先决条件](getting-started.before-you-begin.md)。
*键空间* 对与一个或多个应用程序相关的表进行分组。键空间包含一个或多个表，并为其包含的所有表定义复制策略。有关键空间的更多信息，请参阅以下主题：
+ CQL 语言参考中的数据定义语言（DDL）语句：[Keyspaces](cql.ddl.keyspace.md)
+ [Amazon Keyspaces（Apache Cassandra 兼容）限额](quotas.md)
在本教程中，我们创建一个单区域键空间，键空间的复制策略是 `SingleRegionStrategy`。使用 `SingleRegionStrategy`，Amazon Keyspaces 在一个 AWS 区域的三个[可用区](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)中复制数据。要了解如何创建多区域键空间，请参阅[在 Amazon Keyspaces 中创建多区域键空间](keyspaces-mrr-create.md)。
## 使用控制台
**使用控制台创建键空间**
1. [登录并在家中打开 Amazon Keyspaces 控制台。 AWS 管理控制台 https://console.aws.amazon.com/keyspaces/](https://console.aws.amazon.com/keyspaces/home)
1. 在导航窗格中，选择 **Keyspaces (键空间)**。
1. 选择 **Create keyspace (创建键空间)**。
1. 在 **Keyspace name (键空间名称)** 框中，输入 **catalog** 作为键空间的名称。
**名称约束：**
+ 名称不能为空。
+ 允许的字符：字母数字字符和下划线 (`_`)。
+ 最大长度为 48 个字符。
1. 在 **AWS 区域**下，确认**单区域复制**是键空间的复制策略。
1. 要创建键空间，请选择 **Create keyspace (创建键空间)**。
1. 通过执行以下操作，验证键空间 `catalog` 是否已创建：
1. 在导航窗格中，选择 **Keyspaces (键空间)**。
1. 在键空间列表中，查找键空间 `catalog`。
## 使用 CQL
以下过程使用 CQL 创建键空间。
**使用 CQL 创建键空间**
1. 使用以下 AWS CloudShell 命令打开并连接到 Amazon Keyspaces。请务必*us-east-1*使用您自己的地区进行更新。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
该命令应生成如下所示的输出。
```
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. 使用以下 CQL 命令创建键空间。
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
`SingleRegionStrategy`使用复制系数为三，并在其所在区域的三个 AWS 可用区之间复制数据。
**注意**
Amazon Keyspaces 默认所有输入为小写，除非括在引号中。
1. 验证键空间是否已创建。
```
SELECT * from system_schema.keyspaces;
```
此命令的输出应类似如下：
```
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)
```
## 使用 AWS CLI
以下过程使用 AWS CLI创建键空间。
**要使用创建密钥空间 AWS CLI**
1. 要确认您的环境已设置完毕，可以在中运行以下命令 CloudShell。
```
aws keyspaces help
```
1. 使用以下 AWS CLI 语句创建密钥空间。
```
aws keyspaces create-keyspace --keyspace-name 'catalog'
```
1. 使用以下 AWS CLI 语句验证您的密钥空间是否已创建
```
aws keyspaces get-keyspace --keyspace-name 'catalog'
```
此命令的输出应类似于以下示例。
```
{
"keyspaceName": "catalog",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/",
"replicationStrategy": "SINGLE_REGION"
}
```
# 在 Amazon Keyspaces 中查看键空间的创建状态
Amazon Keyspaces 以异步方式执行数据定义语言 (DDL) 操作，例如创建和删除键空间。
您可以在中监控新密钥空间的创建状态 AWS 管理控制台，该状态会指示密钥空间何时处于待处理状态或处于活动状态。您还可以使用 `system_schema_mcs` 键空间以编程方式监控新键空间的创建状态。一旦键空间可供使用，便会显示在 `system_schema_mcs` `keyspaces` 表中。
要检查新键空间何时可供使用，推荐的设计模式是轮询 Amazon Keyspaces `system_schema_mcs` `keyspaces` 表 (system\$1schema\$1mcs.\$1)。有关键空间的 DDL 语句列表，请参阅 CQL 语言参考中的[Keyspaces](cql.ddl.keyspace.md)部分。
以下查询显示是否已成功创建键空间。
```
SELECT * FROM system_schema_mcs.keyspaces WHERE keyspace_name = 'mykeyspace';
```
对于已成功创建的键空间，此查询的输出如下所示。
```
keyspace_name | durable_writes | replication
--------------+-----------------+--------------
mykeyspace | true |{...} 1 item
```
# 在 Amazon Keyspaces 中创建表
在本部分中，将使用控制台、`cqlsh` 或 AWS CLI创建表。
表是组织和存储数据的位置。表的主键决定如何在表中对数据进行分区。主键由一个必需的分区键和一个或多个可选的聚类列组成。组成主键的组合值在表的所有数据中必须是唯一的。有关表的更多信息，请参阅以下主题：
+ 分区键设计：[如何在 Amazon Keyspaces 中高效使用分区键](bp-partition-key-design.md)
+ 使用表：[在 Amazon Keyspaces 中查看表的创建状态](tables-create.md)
+ CQL 语言参考中的 DDL 语句：[表](cql.ddl.table.md)
+ 表资源管理：[在 Amazon Keyspaces（Apache Cassandra 兼容）中管理无服务器资源](serverless_resource_management.md)
+ 监控表资源利用率：[使用亚马逊监控亚马逊密钥空间 CloudWatch](monitoring-cloudwatch.md)
+ [Amazon Keyspaces（Apache Cassandra 兼容）限额](quotas.md)
创建表时，应指定以下内容：
+ 表的名称。
+ 表中每一列的名称和数据类型。
+ 表的主键。
+ **分区键** – 必需
+ **聚类列** – 可选
可使用以下过程创建具有指定列、数据类型、分区键和集群列的表。
## 使用控制台
以下过程创建包含如下列和数据类型的表 `book_awards`。
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**使用控制台创建表**
1. [登录并在家中打开 Amazon Keyspaces 控制台。 AWS 管理控制台 https://console.aws.amazon.com/keyspaces/](https://console.aws.amazon.com/keyspaces/home)
1. 在导航窗格中，选择 **Keyspaces (键空间)**。
1. 选择 `catalog` 作为要在其中创建此表的键空间。
1. 选择**创建表**。
1. 在 **Table name (表名称)** 框中，输入 **book\$1awards** 作为表的名称。
**名称约束：**
+ 名称不能为空。
+ 允许的字符：字母数字字符和下划线 (`_`)。
+ 最大长度为 48 个字符。
1. 在 **Columns (列)** 部分中，为要添加到此表的每一列重复以下步骤。
添加以下列和数据类型。
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
1. **名称** – 输入列的名称。
**名称约束：**
+ 名称不能为空。
+ 允许的字符：字母数字字符和下划线 (`_`)。
+ 最大长度为 48 个字符。
1. **类型** – 在数据类型列表中，为此列选择数据类型。
1. 要添加其他列，请选择**添加列**。
1. 在**分区键**下，选择 `award` 和 `year` 作为分区键。每个表都需要一个分区键。分区键可以由一列或多列构成。
1. 将 `category` 和 `rank` 添加为**集群列**。聚类列是可选的，决定着每个分区内的排序顺序。
1. 要添加聚类列，请选择 **Add clustering column (添加聚类列)**。
1. 在**列**列表中，选择**类别**。在 **Order (顺序)** 列表中，选择 **ASC (升序)** 按照升序对此列中的值进行排序。（选择 **DESC (降序)** 可按降序排列。）
1. 然后选择**添加集群列**并选择**排名**。
1. 在**表设置**部分中，选择**默认设置**。
1. 选择**创建表**。
1. 验证表是否已创建。
1. 在导航窗格中，选择**表**。
1. 确认您的表位于表列表中。
1. 选择表的名称。
1. 确认所有列和数据类型都正确无误。
**注意**
列的顺序可能与添加到表中的顺序不同。
## 使用 CQL
以下过程使用 CQL 创建包含如下列和数据类型的表。`year` 和 `award` 列是将 `category` 和 `rank` 作为集群列的分区键，它们共同构成表的主键。
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**使用 CQL 创建表**
1. 使用以下 AWS CloudShell 命令打开并连接到 Amazon Keyspaces。请务必*us-east-1*使用您自己的地区进行更新。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
该命令应生成如下所示的输出。
```
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. 在键空间提示符 (`cqlsh:keyspace_name>`) 处，通过在命令窗口中输入以下代码来创建表。
```
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)
);
```
**注意**
`ASC` 是默认的聚类顺序。也可以指定 `DESC` 按降序排列。
请注意，`year` 和 `award` 是分区键列。然后，`category` 和 `rank` 是按升序（`ASC`）排列的集群列。这些列共同构成表的主键。
1. 验证表是否已创建。
```
SELECT * from system_schema.tables WHERE keyspace_name='catalog.book_awards' ;
```
输出应如下所示：
```
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. 验证表的结构。
```
SELECT * FROM system_schema.columns WHERE keyspace_name = 'catalog' AND table_name = 'book_awards';
```
此语句的输出应类似于以下示例。
```
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)
```
确认所有列和数据类型均符合预期。列的顺序可能与 `CREATE` 语句中的顺序不同。
## 使用 AWS CLI
以下过程使用 AWS CLI创建包含如下列和数据类型的表。`year` 和 `award` 列构成分区键，将 `category` 和 `rank` 作为集群列。
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**要使用创建表 AWS CLI**
以下命令可创建一个名为 *book\$1awards* 的表。该表的分区键由 `year` 和 `award` 两列组成，聚类键由 `category` 和 `rank` 两列组成，两个聚类列均使用升序排序。（为便于阅读，本部分中的表创建命令的 `schema-definition` 分行显示。）
1. 使用以下语句创建表。
```
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}]'
```
该命令的输出结果如下。
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards"
}
```
1. 要确认表的元数据和属性，您可以使用以下命令。
```
aws keyspaces get-table --keyspace-name 'catalog' --table-name 'book_awards'
```
此命令将返回以下输出。
```
{
"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": []
}
```
要对表中的数据执行 CRUD（创建、读取、更新和删除）操作，请继续执行[在 Amazon Keyspaces 中使用 CQL 创建、读取、更新和删除数据（CRUD）](getting-started.dml.md)。
# 在 Amazon Keyspaces 中查看表的创建状态
Amazon Keyspaces 以异步方式执行数据定义语言 (DDL) 操作，例如创建和删除表。您可以在中监控新表的创建状态 AWS 管理控制台，这会指示表何时处于待处理状态或活动状态。您还可以使用系统模式表以编程方式监控新表的创建状态。
当表可供使用时，会在系统模式中显示为活动状态。要检查新的表何时可供使用，推荐的设计模式是轮询 Amazon Keyspaces 系统架构表 (`system_schema_mcs.*`)。有关表的 DDL 语句列表，请参阅 CQL 语言参考中的[表](cql.ddl.table.md)部分。
以下查询显示表的状态。
```
SELECT keyspace_name, table_name, status FROM system_schema_mcs.tables WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
对于仍在创建且处于待处理状态的表，此查询的输出如下所示。
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | CREATING
```
对于已成功创建且处于活动状态的表，此查询的输出如下所示。
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | ACTIVE
```
# 在 Amazon Keyspaces 中使用 CQL 创建、读取、更新和删除数据（CRUD）
在本教程的这一步中，您将学习如何使用 CQL 数据操作语言（DML）语句在 Amazon Keyspaces 表中插入、读取、更新和删除数据。在 Amazon Keyspaces 中，您只能使用 CQL 语言创建 DML 语句。在本教程中，您将练习结合使用 `cqlsh-expansion` 与 AWS 管理控制台中的 [AWS CloudShell](using-aws-with-cloudshell.md) 来运行 DML 语句。
+ **插入数据** - 本节介绍如何使用 `INSERT` 语句向表中插入单条以及多条记录。您将学习如何通过 CSV 文件上传数据，以及如何使用 `SELECT` 查询验证插入是否成功。
+ **读取数据** - 在此，您将探索用于从表中检索数据的 `SELECT` 语句的不同变体。主题包括选择所有数据、选择特定列、使用 `WHERE` 子句根据条件筛选行，以及了解简单条件和复合条件。
+ **更新数据** - 在本节中，您将学习如何使用 `UPDATE` 语句修改表中的现有数据。您将练习更新单列和多列，同时了解更新主键列的限制。
+ **删除数据** - 最后一节介绍如何使用 `DELETE` 语句从表中删除数据。您将学习如何删除特定的单元格、整行，以及删除数据与删除整个表或键空间的影响。
在整个教程中，您将找到示例、提示和机会，让您可以练习为各种场景编写自己的 CQL 查询。
**Topics**
+ [在 Amazon Keyspaces 表中插入和加载数据](getting-started.dml.create.md)
+ [在 Amazon Keyspaces 中使用 CQL `SELECT` 语句从表中读取数据](getting-started.dml.read.md)
+ [使用 CQL 更新 Amazon Keyspaces 表中的数据](getting-started.dml.update.md)
+ [使用 CQL `DELETE` 语句从表中删除数据](getting-started.dml.delete.md)
# 在 Amazon Keyspaces 表中插入和加载数据
要在 `book_awards` 表中创建数据，请使用 `INSERT` 语句添加单行。
1. 使用以下 AWS CloudShell 命令打开并连接到 Amazon Keyspaces。请务必*us-east-1*使用您自己的地区进行更新。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
该命令应生成如下所示的输出。
```
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. 在使用 cqlsh 将数据写入 Amazon Keyspaces 表之前，您必须将当前 cqlsh 会话的写入一致性设置为 `LOCAL_QUORUM`。有关支持的一致性级别的更多信息，请参阅[写入一致性级别](consistency.md#WriteConsistency)。请注意，如果您在 AWS 管理控制台中使用 CQL 编辑器，则不需要执行此步骤。
```
CONSISTENCY LOCAL_QUORUM;
```
1. 要插入单个记录，请在 CQL 编辑器中运行以下命令。
```
INSERT INTO catalog.book_awards (award, year, category, rank, author, book_title, publisher)
VALUES ('Wolf', 2023, 'Fiction',3,'Shirley Rodriguez','Mountain', 'AnyPublisher') ;
```
1. 通过运行以下命令，验证数据是否已正确添加到表中。
```
SELECT * FROM catalog.book_awards;
```
语句的输出应如下所示。
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+-------------------+------------+--------------
2023 | Wolf | Fiction | 3 | Shirley Rodriguez | Mountain | AnyPublisher
(1 rows)
```
**使用 cqlsh 从文件插入多个记录**
1. 下载存档文件 [samplemigration.zip](samples/samplemigration.zip) 中包含的示例 CSV 文件（`keyspaces_sample_table.csv`）。解压缩存档文件并记下指向 `keyspaces_sample_table.csv` 的路径。
![\[CSV 文件的屏幕截图，其中显示了导入 csv 文件后表的输出。\]](http://docs.aws.amazon.com/zh_cn/keyspaces/latest/devguide/images/keyspaces-awards.png)
1. AWS CloudShell 在中打开 AWS 管理控制台 并使用以下命令连接到 Amazon Keyspaces。请务必*us-east-1*使用您自己的地区进行更新。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. 在 `cqlsh` 提示符 (`cqlsh>`) 处，指定键空间。
```
USE catalog ;
```
1. 将写入一致性设置为 `LOCAL_QUORUM`。有关支持的一致性级别的更多信息，请参阅[写入一致性级别](consistency.md#WriteConsistency)。
```
CONSISTENCY LOCAL_QUORUM;
```
1. 在屏幕右上角 AWS CloudShell 选择**操作**，然后选择**上传文件上传**之前下载的 csv 文件。记下文件的路径。
1. 在键空间提示符（`cqlsh:catalog>`）处，运行以下语句。
```
COPY book_awards (award, year, category, rank, author, book_title, publisher) FROM '/home/cloudshell-user/keyspaces_sample_table.csv' WITH header=TRUE ;
```
语句的输出应如下所示。
```
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. 通过运行以下查询，验证数据是否已正确添加到表中。
```
SELECT * FROM book_awards ;
```
您应当看到如下输出。
```
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)
```
要详细了解如何使用 `cqlsh COPY` 将 csv 文件中的数据上传到 Amazon Keyspaces 表，请参阅[教程：使用 cqlsh 将数据加载到 Amazon Keyspaces](bulk-upload.md)。
# 在 Amazon Keyspaces 中使用 CQL `SELECT` 语句从表中读取数据
在[在 Amazon Keyspaces 表中插入和加载数据](getting-started.dml.create.md)一节中，您使用 `SELECT` 语句验证了已成功将数据添加到表中。在本节中，您可以细化使用 `SELECT`，以只显示特定列以及满足特定条件的行。
`SELECT` 语句的一般形式如下所示。
```
SELECT column_list FROM table_name [WHERE condition [ALLOW FILTERING]] ;
```
**Topics**
+ [选择表中的所有数据](#getting-started.dml.read.all)
+ [选择列的子集](#getting-started.dml.read.columns)
+ [选择部分行](#getting-started.dml.read.rows)
## 选择表中的所有数据
`SELECT` 语句最简单的形式是返回表中的所有数据。
**重要**
在生产环境中，运行此命令通常不是最佳做法，该命令将返回表中的所有数据。
**选择表的所有数据**
1. 使用以下 AWS CloudShell 命令打开并连接到 Amazon Keyspaces。请务必*us-east-1*使用您自己的地区进行更新。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. 运行以下 查询。
```
SELECT * FROM catalog.book_awards ;
```
将通配符 (`*`) 用于 `column_list` 可选择所有列。语句的输出类似于以下示例。
```
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
```
## 选择列的子集
**查询列的子集**
1. 使用以下 AWS CloudShell 命令打开并连接到 Amazon Keyspaces。请务必*us-east-1*使用您自己的地区进行更新。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. 要仅检索 `award`、`category` 和 `year` 列，请运行以下查询。
```
SELECT award, category, year FROM catalog.book_awards ;
```
输出将按照 `SELECT` 语句中列出的顺序，仅包含指定的列。
```
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
```
## 选择部分行
查询大型数据集时，您可能只需要满足特定条件的记录。为此，您可以在 `SELECT` 语句末尾追加一个 `WHERE` 子句。
**查询行的子集**
1. 使用以下 AWS CloudShell 命令打开并连接到 Amazon Keyspaces。请务必*us-east-1*使用您自己的地区进行更新。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. 要仅检索指定年份的奖项记录，请运行以下查询。
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Wolf' ;
```
前面的 `SELECT` 语句将返回以下输出。
```
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
```
### 了解 `WHERE` 子句
`WHERE` 子句用于筛选数据，并仅返回满足指定条件的数据。指定的条件可以是简单条件或复合条件。
**如何在 `WHERE` 子句中使用条件**
+ 简单条件 – 单列
```
WHERE column_name=value
```
只要满足以下任何条件，便可以在 `WHERE` 子句中使用简单条件：
+ 该列是表的唯一分区键列。
+ 在 `WHERE` 子句中的条件后添加 `ALLOW FILTERING`。
请注意，使用 `ALLOW FILTERING` 可能会导致性能不稳定，特别是对于多分区的大型表。
+ 复合条件 – 通过 `AND` 连接的多个简单条件
```
WHERE column_name1=value1 AND column_name2=value2 AND column_name3=value3...
```
只要满足以下任何条件，便可以在 `WHERE` 子句中使用复合条件：
+ 可以在 `WHERE` 子句中使用的列需要包括表分区键中的所有列或部分列。如果只想使用 `WHERE` 子句中的部分列，则必须从左到右包含一组连续的分区键列，从分区键的第一列开始。例如，如果分区键列为 `year`、`month` 和 `award`，则可以在 `WHERE` 子句中使用以下列：
+ `year`
+ `year` 和 `month`
+ `year` 和 `month` 和 `award`
+ 在 `WHERE` 子句中的复合条件后添加 `ALLOW FILTERING`，如下例所示。
```
SELECT * FROM my_table WHERE col1=5 AND col2='Bob' ALLOW FILTERING ;
```
请注意，使用 `ALLOW FILTERING` 可能会导致性能不稳定，特别是对于多分区的大型表。
### 试试看
创建您自己的 CQL 查询，以从 `book_awards` 表中查找以下内容：
+ 查找 2020 年 Wolf 奖的获奖者并显示书名和作者，按排名排序。
+ 显示 2020 年所有奖项的一等奖得主，并显示书名和奖项名称。
# 使用 CQL 更新 Amazon Keyspaces 表中的数据
要更新 `book_awards` 表中的数据，请使用 `UPDATE` 语句。
`UPDATE` 语句的一般形式如下所示。
```
UPDATE table_name SET column_name=new_value WHERE primary_key=value ;
```
**提示**
您可以使用逗号分隔的 `column_names` 和值列表来更新多列，如下例所示。
```
UPDATE my_table SET col1='new_value_1', col2='new_value2' WHERE col3='1' ;
```
如果主键由多列构成，则必须将所有主键列及其值包含在 `WHERE` 子句中。
不能更新主键中的任何列，因为这会更改记录的主键。
**更新单个单元格**
使用 `book_awards` 表，将出版商的名称更改为 2020 年非小说类 Wolf 奖得主。
```
UPDATE book_awards SET publisher='new Books' WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
确认出版商现在是 `new Books`。
```
SELECT * FROM book_awards WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
语句应返回以下输出。
```
year | award | category | rank | author | book_title | publisher
------+-------+-------------+------+-------------+------------------+-----------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | new Books
```
## 试试看
**高级：**2020 年小说类“Kwezi Manu Prize”的获奖者改了其名称。更新此记录以将名称更改为 `'Akua Mansa-House'`。
# 使用 CQL `DELETE` 语句从表中删除数据
要删除 `book_awards` 表中的数据，请使用 `DELETE` 语句。
您可以从行或分区中删除数据。删除数据时要小心，因为删除是不可逆操作。
从表中删除一行或所有行不会删除该表。因此，您可以用数据重新填充该表。删除表将删除表及其中的所有数据。要再次使用表，必须重新创建表并向其中添加数据。删除键空间会删除键空间及其中的所有表。要使用键空间和表，必须重新创建，然后用数据填充。您可以使用 Amazon Keyspaces Point-in-time (PITR) 恢复来帮助恢复已删除的表，要了解更多信息，请参阅。[使用 Amazon Keyspaces 的 point-in-time恢复功能备份和还原数据](PointInTimeRecovery.md)要了解如何在启用 PITR 的情况下还原已删除的表，请参阅[使用 Amazon Keyspaces PITR 还原已删除的表](restoredeleted.md)。
## 删除单元格
从行中删除列会从指定单元格中删除数据。使用`SELECT`语句显示该列时，数据显示为*null*，尽管该位置没有存储空值。
删除一个或多个特定列的一般语法如下所示。
```
DELETE column_name1[, column_name2...] FROM table_name WHERE condition ;
```
在 `book_awards` 表中，您可以看到荣获 2020 年“Richard Roe”奖第一名的书名是《Long Summer》。想象一下，该书名已被召回，您需要从该单元格中删除数据。
**删除特定单元格**
1. 使用以下 AWS CloudShell 命令打开并连接到 Amazon Keyspaces。请务必*us-east-1*使用您自己的地区进行更新。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. 运行以下 `DELETE` 查询。
```
DELETE book_title FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. 验证删除请求是否如预期。
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
该语句的输出如下所示。
```
year | award | category | rank | author | book_title | publisher
------+-------------+----------+------+-------------------+------------+---------------
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | null | SomePublisher
```
## 删除行
有时您可能需要删除整行，例如为了满足数据删除请求。删除行的一般语法如下所示。
```
DELETE FROM table_name WHERE condition ;
```
**删除行**
1. 使用以下 AWS CloudShell 命令打开并连接到 Amazon Keyspaces。请务必*us-east-1*使用您自己的地区进行更新。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. 运行以下 `DELETE` 查询。
```
DELETE FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. 验证删除操作是否如预期。
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
删除行后，此语句的输出如下所示。
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+--------+------------+-----------
(0 rows)
```
您可以使用 Amazon Keyspaces 生存时间自动从表中删除过期的数据，有关更多信息，请参阅[使用 Amazon Keyspaces（Apache Cassandra 兼容）的生存时间（TTL）功能让数据过期](TTL.md)。
# 在 Amazon Keyspaces 中删除表
为避免为不需要的表和数据支付费用，请删除所有不使用的表。表删除后，该表及其数据将被删除，其费用累计将停止。但是，键空间仍然保留。键空间删除后，键空间及其所有表将被删除，其费用累计将停止。
您可以使用控制台、CQL 或 AWS CLI删除表。表删除后，该表及其所有数据都将被删除。
## 使用控制台
以下过程使用 AWS 管理控制台删除表及其所有数据。
**使用控制台删除表**
1. [登录并在家中打开 Amazon Keyspaces 控制台。 AWS 管理控制台 https://console.aws.amazon.com/keyspaces/](https://console.aws.amazon.com/keyspaces/home)
1. 在导航窗格中，选择**表**。
1. 选中要删除的每个表名称左侧的框。
1. 选择**删除**。
1. 在 **Delete table (删除表)** 屏幕上，在框中输入 **Delete**。然后，选择 **Delete table (删除表)**。
1. 要验证表是否已删除，请在导航窗格中选择 **Tables (表)**，然后确认该 `book_awards` 表已不再列出。
## 使用 CQL
以下过程使用 CQL 删除表及其所有数据。
**使用 CQL 删除表**
1. 使用以下 AWS CloudShell 命令打开并连接到 Amazon Keyspaces。请务必*us-east-1*使用您自己的地区进行更新。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. 通过输入以下语句来删除表。
```
DROP TABLE IF EXISTS catalog.book_awards ;
```
1. 验证表是否已删除。
```
SELECT * FROM system_schema.tables WHERE keyspace_name = 'catalog' ;
```
输出应如下所示：请注意，这可能需要一些时间，因此，如果您没有看到此结果，请在一分钟后重新运行语句。
```
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)
```
## 使用 AWS CLI
以下过程使用 AWS CLI删除表及其所有数据。
**要使用删除表 AWS CLI**
1. 打开 CloudShell
1. 使用以下语句删除表。
```
aws keyspaces delete-table --keyspace-name 'catalog' --table-name 'book_awards'
```
1. 要验证您的表是否已删除，可以在键空间中列出所有表。
```
aws keyspaces list-tables --keyspace-name 'catalog'
```
您应当看到如下输出。请注意，此异步操作可能需要一些时间。稍等片刻后再次运行该命令，以确认表已被删除。
```
{
"tables": []
}
```
# 在 Amazon Keyspaces 中删除键空间
为避免为键空间付费，请删除所有未使用的键空间。键空间删除后，键空间及其所有表将被删除，其费用累计将停止。
您可以使用控制台、CQL、或 AWS CLI删除键空间。
## 使用控制台
以下过程使用控制台删除键空间及其所有表和数据。
**使用控制台删除键空间**
1. [登录并在家中打开 Amazon Keyspaces 控制台。 AWS 管理控制台 https://console.aws.amazon.com/keyspaces/](https://console.aws.amazon.com/keyspaces/home)
1. 在导航窗格中，选择 **Keyspaces (键空间)**。
1. 选中要删除的每个键空间名称左侧的框。
1. 选择**删除**。
1. 在 **Delete keyspace (删除键空间)** 屏幕上，在框中输入 **Delete**。然后，选择 **Delete keyspace (删除键空间)**。
1. 要验证键空间 `catalog` 是否已删除，请在导航窗格中选择 **Keyspaces (键空间)**，然后确认该键空间已不再列出。因为您删除了其键空间，所以**表**下的 `book_awards` 表也不应被列出。
## 使用 CQL
以下过程使用 CQL 删除键空间及其所有表和数据。
**使用 CQL 删除键空间**
1. 使用以下 AWS CloudShell 命令打开并连接到 Amazon Keyspaces。请务必*us-east-1*使用您自己的地区进行更新。
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. 通过输入以下语句来删除键空间。
```
DROP KEYSPACE IF EXISTS catalog ;
```
1. 验证键空间是否已删除。
```
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'}
(4 rows)
```
## 使用 AWS CLI
以下过程使用 AWS CLI删除键空间及其所有表和数据。
**要使用删除密钥空间 AWS CLI**
1. 打开 AWS CloudShell
1. 通过输入以下语句来删除键空间。
```
aws keyspaces delete-keyspace --keyspace-name 'catalog'
```
1. 验证键空间是否已删除。
```
aws keyspaces list-keyspaces
```
此语句的输出应与此类似，并且仅列出系统密钥空间。请注意，由于这是异步操作，因此在删除密钥空间之前可能会有一段延迟。
```
{
"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"
}
]
}
```