Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erste Schritte mit Amazon Keyspaces (für Apache Cassandra)
Wenn Sie mit Apache Cassandra und Amazon Keyspaces noch nicht vertraut sind, führt Sie dieses Tutorial durch die Installation der erforderlichen Programme und Tools, um Amazon Keyspaces erfolgreich zu verwenden. Sie lernen, wie Sie mit Cassandra Query Language (CQL), the oder the () einen Schlüsselraum und eine Tabelle erstellen. AWS-Managementkonsole AWS Command Line Interface AWS CLI Anschließend verwenden Sie Cassandra Query Language (CQL), um Erstellungs-, Lese-, Aktualisierungs- und Löschvorgänge (CRUD) für Daten in Ihrer Amazon Keyspaces-Tabelle durchzuführen.
Dieses Tutorial behandelt die folgenden Schritte.
+ **Voraussetzungen** — Bevor Sie mit dem Tutorial beginnen, folgen Sie den Anweisungen zur AWS Einrichtung, um sich für einen IAM-Benutzer mit Zugriff auf Amazon Keyspaces zu registrieren AWS und diesen zu erstellen. Dann richten Sie das und ein. `cqhsh-expansion` AWS CloudShell Alternativ können Sie das verwenden AWS CLI , um Ressourcen in Amazon Keyspaces zu erstellen.
+ **Schritt 1: Erstellen Sie einen Schlüsselraum und eine Tabelle** — In diesem Abschnitt erstellen Sie einen Schlüsselraum mit dem Namen „catalog“ und darin eine Tabelle mit dem Namen „book\$1awards“. Sie geben die Spalten, Datentypen, den Partitionsschlüssel und die Clusterspalte der Tabelle mit dem AWS-Managementkonsole, CQL oder dem an. AWS CLI
+ **Schritt 2: CRUD-Operationen durchführen** — Hier verwenden Sie das in, CloudShell um Daten `cqlsh-expansion` in die Tabelle „book\$1awards“ einzufügen, zu lesen, zu aktualisieren und zu löschen. Sie lernen, verschiedene CQL-Anweisungen wie SELECT, INSERT, UPDATE und DELETE zu verwenden, und üben das Filtern und Ändern von Daten.
+ **Schritt 3: Ressourcen bereinigen** — Um zu vermeiden, dass Gebühren für ungenutzte Ressourcen anfallen, führt Sie dieser Abschnitt durch das Löschen der Tabelle „book\$1awards“ und des Schlüsselraums „catalog“ mithilfe der Konsole, CQL oder der. AWS CLI
Tutorials zur programmgesteuerten Verbindung mit Amazon Keyspaces mithilfe verschiedener Apache Cassandra-Clienttreiber finden Sie unter. [Verwenden eines Cassandra-Client-Treibers für den programmgesteuerten Zugriff auf Amazon Keyspaces](programmatic.drivers.md) Codebeispiele, die verschiedene verwenden AWS SDKs, finden Sie unter [Codebeispiele für die Verwendung von AWS SDKs Amazon Keyspaces](https://docs.aws.amazon.com/keyspaces/latest/devguide/service_code_examples.html).
**Topics**
+ [Voraussetzungen und Überlegungen zum Tutorial](getting-started.before-you-begin.md)
+ [Erstellen Sie einen Schlüsselraum in Amazon Keyspaces](getting-started.keyspaces.md)
+ [Überprüfen Sie den Status der Schlüsselraumerstellung in Amazon Keyspaces](keyspaces-create.md)
+ [Eine Tabelle in Amazon Keyspaces erstellen](getting-started.tables.md)
+ [Überprüfen Sie den Status der Tabellenerstellung in Amazon Keyspaces](tables-create.md)
+ [Daten (CRUD) mit CQL in Amazon Keyspaces erstellen, lesen, aktualisieren und löschen](getting-started.dml.md)
+ [Löschen Sie eine Tabelle in Amazon Keyspaces](getting-started.clean-up.table.md)
+ [Löschen Sie einen Schlüsselraum in Amazon Keyspaces](getting-started.clean-up.keyspace.md)
# Voraussetzungen und Überlegungen zum Tutorial
Bevor Sie mit Amazon Keyspaces beginnen können, folgen Sie den Anweisungen zur AWS Einrichtung unter. [Zugreifen auf Amazon Keyspaces (für Apache Cassandra)](accessing.md) Zu diesen Schritten gehören die Registrierung AWS und Erstellung eines AWS Identity and Access Management (IAM-) Benutzers mit Zugriff auf Amazon Keyspaces.
Um alle Schritte des Tutorials abzuschließen, müssen Sie installieren. `cqlsh` Sie können den Anweisungen zur Einrichtung unter folgen[Verwenden`cqlsh`, um eine Verbindung zu Amazon Keyspaces herzustellen](programmatic.cqlsh.md).
Um mit `cqlsh` oder auf Amazon Keyspaces zuzugreifen AWS CLI, empfehlen wir die Verwendung von AWS CloudShell. CloudShellist eine browserbasierte, vorauthentifizierte Shell, die Sie direkt von der aus starten können. AWS-Managementkonsole Sie können AWS Command Line Interface (AWS CLI) -Befehle für Amazon Keyspaces mit Ihrer bevorzugten Shell (Bash PowerShell oder Z-Shell) ausführen. Um es zu verwenden`cqlsh`, müssen Sie das installieren. `cqlsh-expansion` `cqlsh-expansion`Installationsanweisungen finden Sie unter[Verwenden von`cqlsh-expansion`, um eine Verbindung zu Amazon Keyspaces herzustellen](programmatic.cqlsh.md#using_cqlsh). Weitere Informationen zu finden CloudShell Sie unter[Für AWS CloudShell den Zugriff auf Amazon Keyspaces verwenden](using-aws-with-cloudshell.md).
Folgen Sie den Anweisungen AWS CLI zur Einrichtung unter, um Ressourcen in Amazon Keyspaces zu erstellen, anzuzeigen und zu [Herunterladen und Konfigurieren des AWS CLI](access.cli.md#access.cli.installcli) löschen.
Nachdem Sie die erforderlichen Schritte abgeschlossen haben, fahren Sie mit fort[Erstellen Sie einen Schlüsselraum in Amazon Keyspaces](getting-started.keyspaces.md).
# Erstellen Sie einen Schlüsselraum in Amazon Keyspaces
In diesem Abschnitt erstellen Sie einen Schlüsselraum mit der Konsole oder dem. `cqlsh` AWS CLI
**Anmerkung**
Bevor Sie beginnen, stellen Sie sicher, dass Sie alle [Voraussetzungen für das Tutorial](getting-started.before-you-begin.md) konfiguriert haben.
Ein *Schlüsselraum* gruppiert verwandte Tabellen, die für eine oder mehrere Anwendungen relevant sind. Ein Schlüsselraum enthält eine oder mehrere Tabellen und definiert die Replikationsstrategie für alle darin enthaltenen Tabellen. Weitere Informationen zu Schlüsselräumen finden Sie in den folgenden Themen:
+ DDL-Anweisungen (Data Definition Language) in der CQL-Sprachreferenz: [Keyspaces](cql.ddl.keyspace.md)
+ [Kontingente für Amazon Keyspaces (für Apache Cassandra)](quotas.md)
In diesem Tutorial erstellen wir einen Schlüsselraum mit einer einzelnen Region, und die Replikationsstrategie für den Schlüsselraum lautet. `SingleRegionStrategy` Mithilfe von `SingleRegionStrategy` Amazon Keyspaces repliziert Amazon Keyspaces Daten über drei [Availability Zones](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) in einer. AWS-Region Informationen zum Erstellen von Schlüsselräumen für mehrere Regionen finden Sie unter. [Einen multiregionalen Schlüsselraum in Amazon Keyspaces erstellen](keyspaces-mrr-create.md)
## Verwenden der Konsole
**So erstellen Sie mithilfe der Konsole einen Schlüsselraum**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Keyspaces-Konsole zu [https://console.aws.amazon.com/keyspaces/Hause](https://console.aws.amazon.com/keyspaces/home).
1. Wählen Sie im Navigationsbereich **Keyspaces** aus.
1. Wählen Sie „**Schlüsselraum erstellen**“.
1. Geben Sie **catalog** im Feld „**Schlüsselraumname**“ den Namen für Ihren Schlüsselraum ein.
**Einschränkungen für Namen:**
+ Der Name darf nicht leer sein.
+ Zulässige Zeichen: alphanumerische Zeichen und Unterstrich ()`_`.
+ Die maximale Länge beträgt 48 Zeichen.
1. Bestätigen Sie unter **AWS-Regionen**, dass die **Replikationsstrategie für den Schlüsselraum die Replikationsstrategie für eine einzelne Region** ist.
1. **Um den Schlüsselraum zu erstellen, wählen Sie „Schlüsselraum erstellen“.**
1. Stellen Sie sicher, dass der Schlüsselraum erstellt `catalog` wurde, indem Sie wie folgt vorgehen:
1. Wählen Sie im Navigationsbereich **Keyspaces** aus.
1. Suchen Sie Ihren Schlüsselraum `catalog` in der Liste der Schlüsselräume.
## Verwenden Sie CQL
Das folgende Verfahren erstellt mithilfe von CQL einen Schlüsselraum.
**Um einen Schlüsselraum mit CQL zu erstellen**
1. Öffnen Sie Amazon Keyspaces AWS CloudShell und stellen Sie mithilfe des folgenden Befehls eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Die Ausgabe dieses Befehls sollte so aussehen.
```
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. Erstellen Sie Ihren Keyspace mit dem folgenden CQL-Befehl.
```
CREATE KEYSPACE catalog WITH REPLICATION = {'class': 'SingleRegionStrategy'};
```
`SingleRegionStrategy`verwendet einen Replikationsfaktor von drei und repliziert Daten in drei AWS Availability Zones in seiner Region.
**Anmerkung**
Amazon Keyspaces verwendet standardmäßig alle Eingaben in Kleinbuchstaben, sofern Sie sie nicht in Anführungszeichen setzen.
1. Stellen Sie sicher, dass Ihr Keyspace erstellt wurde.
```
SELECT * from system_schema.keyspaces;
```
Die Ausgabe dieses Befehls sollte in etwa so aussehen.
```
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)
```
## Mit dem AWS CLI
Das folgende Verfahren erstellt einen Schlüsselraum mit dem AWS CLI.
**Um einen Schlüsselraum mit dem zu erstellen AWS CLI**
1. Um zu überprüfen, ob Ihre Umgebung eingerichtet ist, können Sie den folgenden Befehl in CloudShell ausführen.
```
aws keyspaces help
```
1. Erstellen Sie Ihren Schlüsselraum mit der folgenden AWS CLI Anweisung.
```
aws keyspaces create-keyspace --keyspace-name 'catalog'
```
1. Stellen Sie mit der folgenden Anweisung sicher, dass Ihr Schlüsselraum erstellt wurde AWS CLI
```
aws keyspaces get-keyspace --keyspace-name 'catalog'
```
Die Ausgabe dieses Befehls sollte diesem Beispiel ähneln.
```
{
"keyspaceName": "catalog",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/",
"replicationStrategy": "SINGLE_REGION"
}
```
# Überprüfen Sie den Status der Schlüsselraumerstellung in Amazon Keyspaces
Amazon Keyspaces führt DDL-Operationen (Data Definition Language), wie z. B. das Erstellen und Löschen von Schlüsselräumen, asynchron aus.
Sie können den Erstellungsstatus neuer Schlüsselräume in der überwachen AWS-Managementkonsole, was angibt, ob ein Schlüsselraum aussteht oder aktiv ist. Sie können den Erstellungsstatus eines neuen Schlüsselraums auch programmgesteuert mithilfe des Schlüsselraums überwachen. `system_schema_mcs` Ein Schlüsselraum wird in der `system_schema_mcs` `keyspaces` Tabelle sichtbar, wenn er einsatzbereit ist.
Das empfohlene Entwurfsmuster, um zu überprüfen, wann ein neuer Keyspace einsatzbereit ist, besteht darin, die Amazon `system_schema_mcs` `keyspaces` Keyspaces-Tabelle (system\$1schema\$1mcs.\$1) abzufragen. Eine Liste der DDL-Anweisungen für Schlüsselräume finden Sie im Abschnitt der CQL-Sprachreferenz. [Keyspaces](cql.ddl.keyspace.md)
Die folgende Abfrage zeigt, ob ein Schlüsselraum erfolgreich erstellt wurde.
```
SELECT * FROM system_schema_mcs.keyspaces WHERE keyspace_name = 'mykeyspace';
```
Für einen Schlüsselraum, der erfolgreich erstellt wurde, sieht die Ausgabe der Abfrage wie folgt aus.
```
keyspace_name | durable_writes | replication
--------------+-----------------+--------------
mykeyspace | true |{...} 1 item
```
# Eine Tabelle in Amazon Keyspaces erstellen
In diesem Abschnitt erstellen Sie eine Tabelle mit der Konsole oder `cqlsh` dem. AWS CLI
In einer Tabelle werden Ihre Daten organisiert und gespeichert. Der Primärschlüssel Ihrer Tabelle bestimmt, wie Daten in Ihrer Tabelle partitioniert werden. Der Primärschlüssel besteht aus einem erforderlichen Partitionsschlüssel und einer oder mehreren optionalen Clusterspalten. Die kombinierten Werte, aus denen sich der Primärschlüssel zusammensetzt, müssen für alle Daten der Tabelle eindeutig sein. Weitere Informationen zu Tabellen finden Sie in den folgenden Themen:
+ Design des Partitionsschlüssels: [So verwenden Sie Partitionsschlüssel effektiv in Amazon Keyspaces](bp-partition-key-design.md)
+ Mit Tabellen arbeiten: [Überprüfen Sie den Status der Tabellenerstellung in Amazon Keyspaces](tables-create.md)
+ DDL-Anweisungen in der CQL-Sprachreferenz: [Tabellen](cql.ddl.table.md)
+ Verwaltung von Tabellenressourcen: [Verwaltung serverloser Ressourcen in Amazon Keyspaces (für Apache Cassandra)](serverless_resource_management.md)
+ Überwachung der Auslastung der Tabellenressourcen: [Überwachung von Amazon Keyspaces mit Amazon CloudWatch](monitoring-cloudwatch.md)
+ [Kontingente für Amazon Keyspaces (für Apache Cassandra)](quotas.md)
Wenn Sie eine Tabelle erstellen, geben Sie Folgendes an:
+ Der Name der Tabelle.
+ Der Name und der Datentyp jeder Spalte in der Tabelle.
+ Der Primärschlüssel für die Tabelle.
+ **Partitionsschlüssel** — Erforderlich
+ **Spalten gruppieren** — optional
Gehen Sie wie folgt vor, um eine Tabelle mit den angegebenen Spalten, Datentypen, Partitionsschlüsseln und Clusterspalten zu erstellen.
## Verwenden der Konsole
Mit dem folgenden Verfahren wird die Tabelle `book_awards` mit diesen Spalten und Datentypen erstellt.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Um eine Tabelle mit der Konsole zu erstellen**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Keyspaces-Konsole zu [https://console.aws.amazon.com/keyspaces/Hause](https://console.aws.amazon.com/keyspaces/home).
1. Wählen Sie im Navigationsbereich **Keyspaces** aus.
1. Wählen Sie `catalog` den Schlüsselraum aus, in dem Sie diese Tabelle erstellen möchten.
1. Wählen Sie **Create table** (Tabelle erstellen) aus.
1. Geben Sie **book\$1awards** im Feld **Tabellenname** einen Namen für Ihre Tabelle ein.
**Einschränkungen für Namen:**
+ Der Name darf nicht leer sein.
+ Zulässige Zeichen: alphanumerische Zeichen und Unterstrich ()`_`.
+ Die maximale Länge beträgt 48 Zeichen.
1. Wiederholen Sie im Abschnitt **Spalten** die folgenden Schritte für jede Spalte, die Sie zu dieser Tabelle hinzufügen möchten.
Fügen Sie die folgenden Spalten und Datentypen hinzu.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
1. **Name** — Geben Sie einen Namen für die Spalte ein.
**Einschränkungen für Namen:**
+ Der Name darf nicht leer sein.
+ Zulässige Zeichen: alphanumerische Zeichen und Unterstrich ()`_`.
+ Die maximale Länge beträgt 48 Zeichen.
1. **Typ** — Wählen Sie in der Liste der Datentypen den Datentyp für diese Spalte aus.
1. Um eine weitere Spalte hinzuzufügen, wählen Sie **Spalte hinzufügen** aus.
1. Wählen Sie `award` und `year` als Partitionsschlüssel unter **Partitionsschlüssel** aus. Für jede Tabelle ist ein Partitionsschlüssel erforderlich. Ein Partitionsschlüssel kann aus einer oder mehreren Spalten bestehen.
1. Fügen Sie `category` und `rank` als **Clustering-Spalten** hinzu. Clusterspalten sind optional und bestimmen die Sortierreihenfolge innerhalb jeder Partition.
1. Um eine Clusterspalte hinzuzufügen, wählen Sie Clustering-Spalte **hinzufügen** aus.
1. **Wählen Sie in der **Spaltenliste** die Kategorie aus.** Wählen Sie in der Liste **Reihenfolge** die Option **ASC** aus, um die Werte in dieser Spalte in aufsteigender Reihenfolge zu sortieren. (Wählen Sie **DESC** für eine absteigende Reihenfolge.)
1. **Wählen Sie dann **Clusterspalte hinzufügen** und anschließend Rang aus.**
1. Wählen Sie im Abschnitt **Tabelleneinstellungen** die Option **Standardeinstellungen** aus.
1. Wählen Sie **Create table** (Tabelle erstellen) aus.
1. Vergewissern Sie sich, dass Ihre Tabelle erstellt wurde.
1. Wählen Sie im Navigationsbereich **Tables** (Tabellen) aus.
1. Vergewissern Sie sich, dass Ihre Tabelle in der Tabellenliste enthalten ist.
1. Wählen Sie den Namen Ihrer Tabelle.
1. Vergewissern Sie sich, dass alle Ihre Spalten und Datentypen korrekt sind.
**Anmerkung**
Die Spalten werden möglicherweise nicht in der Reihenfolge aufgeführt, in der Sie sie der Tabelle hinzugefügt haben.
## Verwenden von CQL
Dieses Verfahren erstellt mithilfe von CQL eine Tabelle mit den folgenden Spalten und Datentypen. Die `award` Spalten `year` und sind Partitionsschlüssel mit `category` und `rank` als Clusterspalten. Zusammen bilden sie den Primärschlüssel der Tabelle.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Um eine Tabelle mit CQL zu erstellen**
1. Öffnen Sie Amazon Keyspaces AWS CloudShell und stellen Sie mithilfe des folgenden Befehls eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Die Ausgabe dieses Befehls sollte so aussehen.
```
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. Erstellen Sie an der Keyspace-Eingabeaufforderung (`cqlsh:keyspace_name>`) Ihre Tabelle, indem Sie den folgenden Code in Ihr Befehlsfenster eingeben.
```
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)
);
```
**Anmerkung**
`ASC`ist die standardmäßige Clusterreihenfolge. Sie können auch eine `DESC` absteigende Reihenfolge angeben.
Beachten Sie, dass es sich bei den Spalten `year` und um Partitionsschlüsselspalten `award` handelt. Dann `category` und `rank` sind die Clusterspalten in aufsteigender Reihenfolge angeordnet ()`ASC`. Zusammen bilden diese Spalten den Primärschlüssel der Tabelle.
1. Stellen Sie sicher, dass Ihre Tabelle erstellt wurde.
```
SELECT * from system_schema.tables WHERE keyspace_name='catalog.book_awards' ;
```
Die Ausgabe sollte in etwa so aussehen.
```
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. Überprüfen Sie die Struktur Ihrer Tabelle.
```
SELECT * FROM system_schema.columns WHERE keyspace_name = 'catalog' AND table_name = 'book_awards';
```
Die Ausgabe dieser Anweisung sollte diesem Beispiel ähneln.
```
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)
```
Vergewissern Sie sich, dass alle Spalten und Datentypen Ihren Erwartungen entsprechen. Die Reihenfolge der Spalten kann sich von der Reihenfolge in der `CREATE` Anweisung unterscheiden.
## Unter Verwendung der AWS CLI
Dieses Verfahren erstellt eine Tabelle mit den folgenden Spalten und Datentypen unter Verwendung von AWS CLI. Die `award` Spalten `year` und bilden den Partitionsschlüssel mit `category` und `rank` als Clusterspalten.
```
year int
award text
rank int
category text
book_title text
author text
publisher text
```
**Um eine Tabelle mit dem zu erstellen AWS CLI**
Der folgende Befehl erstellt eine Tabelle mit dem Namen *book\$1awards*. Der Partitionsschlüssel der Tabelle besteht aus den Spalten `year` `award` und der Gruppierungsschlüssel besteht aus den Spalten`rank`, `category` und beide Clusterspalten verwenden die aufsteigende Sortierreihenfolge. (Der besseren Lesbarkeit halber ist `schema-definition` der Befehl table create in diesem Abschnitt in separate Zeilen aufgeteilt.)
1. Sie können die Tabelle mit der folgenden Anweisung erstellen.
```
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}]'
```
Dieser Befehl führt zu der folgenden Ausgabe.
```
{
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/catalog/table/book_awards"
}
```
1. Um die Metadaten und Eigenschaften der Tabelle zu bestätigen, können Sie den folgenden Befehl verwenden.
```
aws keyspaces get-table --keyspace-name 'catalog' --table-name 'book_awards'
```
Dieser Befehl gibt die folgende Ausgabe zurück.
```
{
"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": []
}
```
Um CRUD-Operationen (Create, Read, Update, Delete) für die Daten in Ihrer Tabelle durchzuführen, fahren Sie mit fort[Daten (CRUD) mit CQL in Amazon Keyspaces erstellen, lesen, aktualisieren und löschen](getting-started.dml.md).
# Überprüfen Sie den Status der Tabellenerstellung in Amazon Keyspaces
Amazon Keyspaces führt DDL-Operationen (Data Definition Language), wie das Erstellen und Löschen von Tabellen, asynchron aus. Sie können den Erstellungsstatus neuer Tabellen in der überwachen AWS-Managementkonsole, was angibt, ob eine Tabelle ausstehend oder aktiv ist. Sie können den Erstellungsstatus einer neuen Tabelle auch programmgesteuert überwachen, indem Sie die Systemschematabelle verwenden.
Eine Tabelle wird im Systemschema als aktiv angezeigt, wenn sie einsatzbereit ist. Das empfohlene Entwurfsmuster, um zu überprüfen, wann eine neue Tabelle einsatzbereit ist, besteht darin, die Amazon Keyspaces-Systemschematabellen (`system_schema_mcs.*`) abzufragen. Eine Liste der DDL-Anweisungen für Tabellen finden Sie im [Tabellen](cql.ddl.table.md) Abschnitt der CQL-Sprachreferenz.
Die folgende Abfrage zeigt den Status einer Tabelle.
```
SELECT keyspace_name, table_name, status FROM system_schema_mcs.tables WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Für eine Tabelle, die noch erstellt wird und noch aussteht, sieht die Ausgabe der Abfrage wie folgt aus.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | CREATING
```
Für eine Tabelle, die erfolgreich erstellt wurde und aktiv ist, sieht die Ausgabe der Abfrage wie folgt aus.
```
keyspace_name | table_name | status
--------------+------------+--------
mykeyspace | mytable | ACTIVE
```
# Daten (CRUD) mit CQL in Amazon Keyspaces erstellen, lesen, aktualisieren und löschen
In diesem Schritt des Tutorials erfahren Sie, wie Sie mithilfe von CQL Data Manipulation Language (DML) -Anweisungen Daten in eine Amazon Keyspaces-Tabelle einfügen, lesen, aktualisieren und löschen. In Amazon Keyspaces können Sie nur DML-Anweisungen in CQL-Sprache erstellen. In diesem Tutorial üben Sie das Ausführen von DML-Anweisungen mithilfe von with in der`cqlsh-expansion`. [AWS CloudShell](using-aws-with-cloudshell.md) AWS-Managementkonsole
+ **Daten einfügen** — In diesem Abschnitt wird das Einfügen einzelner und mehrerer Datensätze in eine Tabelle mithilfe der Anweisung behandelt. `INSERT` Sie erfahren, wie Sie Daten aus einer CSV-Datei hochladen und erfolgreiche Einfügungen mithilfe `SELECT` von Abfragen überprüfen.
+ **Daten lesen** — Hier lernen Sie verschiedene Varianten der `SELECT` Anweisung zum Abrufen von Daten aus einer Tabelle kennen. Zu den Themen gehören das Auswählen aller Daten, das Auswählen bestimmter Spalten, das Filtern von Zeilen anhand von Bedingungen mithilfe der `WHERE` Klausel und das Verständnis einfacher und zusammengesetzter Bedingungen.
+ **Daten aktualisieren** — In diesem Abschnitt erfahren Sie, wie Sie vorhandene Daten in einer Tabelle mithilfe der `UPDATE` Anweisung ändern können. Sie werden das Aktualisieren einzelner und mehrerer Spalten üben und gleichzeitig die Einschränkungen im Zusammenhang mit der Aktualisierung von Primärschlüsselspalten verstehen.
+ **Daten löschen** — Der letzte Abschnitt behandelt das Löschen von Daten aus einer Tabelle mithilfe der `DELETE` Anweisung. Sie erfahren, wie Sie bestimmte Zellen und ganze Zeilen löschen und welche Auswirkungen das Löschen von Daten im Vergleich zum Löschen der gesamten Tabelle oder des Schlüsselraums hat.
Im gesamten Tutorial finden Sie Beispiele, Tipps und Möglichkeiten, das Schreiben eigener CQL-Abfragen für verschiedene Szenarien zu üben.
**Topics**
+ [Daten in eine Amazon Keyspaces-Tabelle einfügen und laden](getting-started.dml.create.md)
+ [Daten aus einer Tabelle mithilfe der `SELECT` CQL-Anweisung in Amazon Keyspaces lesen](getting-started.dml.read.md)
+ [Daten in einer Amazon Keyspaces-Tabelle mithilfe von CQL aktualisieren](getting-started.dml.update.md)
+ [Löschen Sie Daten aus einer Tabelle mithilfe der CQL-Anweisung `DELETE`](getting-started.dml.delete.md)
# Daten in eine Amazon Keyspaces-Tabelle einfügen und laden
Um Daten in Ihrer `book_awards` Tabelle zu erstellen, verwenden Sie die `INSERT` Anweisung, um eine einzelne Zeile hinzuzufügen.
1. Öffnen Sie Amazon Keyspaces AWS CloudShell und stellen Sie mithilfe des folgenden Befehls eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
Die Ausgabe dieses Befehls sollte so aussehen.
```
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. Bevor Sie mit cqlsh Daten in Ihre Amazon Keyspaces-Tabelle schreiben können, müssen Sie die Schreibkonsistenz für die aktuelle Cqlsh-Sitzung auf einstellen. `LOCAL_QUORUM` Weitere Informationen zu den unterstützten Konsistenzstufen finden Sie unter. [Konsistenzstufen für Schreibvorgänge](consistency.md#WriteConsistency) Beachten Sie, dass dieser Schritt nicht erforderlich ist, wenn Sie den CQL-Editor in der AWS-Managementkonsole verwenden.
```
CONSISTENCY LOCAL_QUORUM;
```
1. Um einen einzelnen Datensatz einzufügen, führen Sie den folgenden Befehl im CQL-Editor aus.
```
INSERT INTO catalog.book_awards (award, year, category, rank, author, book_title, publisher)
VALUES ('Wolf', 2023, 'Fiction',3,'Shirley Rodriguez','Mountain', 'AnyPublisher') ;
```
1. Stellen Sie sicher, dass die Daten korrekt zu Ihrer Tabelle hinzugefügt wurden, indem Sie den folgenden Befehl ausführen.
```
SELECT * FROM catalog.book_awards;
```
Die Ausgabe der Anweisung sollte wie folgt aussehen.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+-------------------+------------+--------------
2023 | Wolf | Fiction | 3 | Shirley Rodriguez | Mountain | AnyPublisher
(1 rows)
```
**Um mehrere Datensätze aus einer Datei mit cqlsh einzufügen**
1. [Laden Sie die CSV-Beispieldatei (`keyspaces_sample_table.csv`) herunter, die in der Archivdatei samplemigration.zip enthalten ist.](samples/samplemigration.zip) Entpacken Sie das Archiv und notieren Sie sich den Pfad zu`keyspaces_sample_table.csv`.
![\[Screenshot einer CSV-Datei, die die Ausgabe der Tabelle nach dem Import der CSV-Datei zeigt.\]](http://docs.aws.amazon.com/de_de/keyspaces/latest/devguide/images/keyspaces-awards.png)
1. Öffnen Sie AWS CloudShell in AWS-Managementkonsole und stellen Sie mit dem folgenden Befehl eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Geben Sie an der `cqlsh` Eingabeaufforderung (`cqlsh>`) einen Schlüsselraum an.
```
USE catalog ;
```
1. Stellen Sie die Schreibkonsistenz auf ein. `LOCAL_QUORUM` Weitere Informationen zu den unterstützten Konsistenzstufen finden Sie unter[Konsistenzstufen für Schreibvorgänge](consistency.md#WriteConsistency).
```
CONSISTENCY LOCAL_QUORUM;
```
1. AWS CloudShell Wählen Sie oben rechts auf dem Bildschirm **Aktionen** und anschließend **Datei hochladen**, um die zuvor heruntergeladene CSV-Datei hochzuladen. Notieren Sie sich den Pfad zur Datei.
1. Führen Sie an der Keyspace-Eingabeaufforderung (`cqlsh:catalog>`) die folgende Anweisung aus.
```
COPY book_awards (award, year, category, rank, author, book_title, publisher) FROM '/home/cloudshell-user/keyspaces_sample_table.csv' WITH header=TRUE ;
```
Die Ausgabe der Anweisung sollte in etwa so aussehen.
```
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. Stellen Sie sicher, dass die Daten korrekt zu Ihrer Tabelle hinzugefügt wurden, indem Sie die folgende Abfrage ausführen.
```
SELECT * FROM book_awards ;
```
Die Ausgabe sollte folgendermaßen aussehen.
```
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)
```
Weitere Informationen `cqlsh COPY` zum Hochladen von Daten aus CSV-Dateien in eine Amazon Keyspaces-Tabelle finden Sie unter[Tutorial: Daten mit cqlsh in Amazon Keyspaces laden](bulk-upload.md).
# Daten aus einer Tabelle mithilfe der `SELECT` CQL-Anweisung in Amazon Keyspaces lesen
In [Daten in eine Amazon Keyspaces-Tabelle einfügen und laden](getting-started.dml.create.md) diesem Abschnitt haben Sie anhand der `SELECT` Anweisung überprüft, ob Sie Ihrer Tabelle erfolgreich Daten hinzugefügt haben. In diesem Abschnitt verfeinern Sie Ihre Verwendung von, `SELECT` um bestimmte Spalten und nur Zeilen anzuzeigen, die bestimmte Kriterien erfüllen.
Die allgemeine Form der `SELECT` Aussage lautet wie folgt.
```
SELECT column_list FROM table_name [WHERE condition [ALLOW FILTERING]] ;
```
**Topics**
+ [Wählen Sie alle Daten in Ihrer Tabelle aus](#getting-started.dml.read.all)
+ [Wählen Sie eine Teilmenge von Spalten](#getting-started.dml.read.columns)
+ [Wählen Sie eine Teilmenge von Zeilen aus](#getting-started.dml.read.rows)
## Wählen Sie alle Daten in Ihrer Tabelle aus
Die einfachste Form der `SELECT` Anweisung gibt alle Daten in Ihrer Tabelle zurück.
**Wichtig**
In einer Produktionsumgebung ist es in der Regel nicht empfehlenswert, diesen Befehl auszuführen, da er alle Daten in Ihrer Tabelle zurückgibt.
**Um alle Daten Ihrer Tabelle auszuwählen**
1. Öffnen Sie Amazon Keyspaces AWS CloudShell und stellen Sie mithilfe des folgenden Befehls eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Führen Sie die folgende Abfrage aus.
```
SELECT * FROM catalog.book_awards ;
```
Wenn Sie das Platzhalterzeichen (`*`) für verwenden, werden alle `column_list` Spalten ausgewählt. Die Ausgabe der Anweisung sieht wie das folgende Beispiel aus.
```
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
```
## Wählen Sie eine Teilmenge von Spalten
**Um eine Teilmenge von Spalten abzufragen**
1. Öffnen Sie Amazon Keyspaces AWS CloudShell und stellen Sie mithilfe des folgenden Befehls eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Führen Sie die folgende Abfrage aus `award``category`, um nur die `year` Spalten, und abzurufen.
```
SELECT award, category, year FROM catalog.book_awards ;
```
Die Ausgabe enthält nur die angegebenen Spalten in der Reihenfolge, die in der `SELECT` Anweisung aufgeführt ist.
```
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
```
## Wählen Sie eine Teilmenge von Zeilen aus
Wenn Sie einen großen Datensatz abfragen, möchten Sie möglicherweise nur Datensätze, die bestimmte Kriterien erfüllen. Zu diesem Zweck können Sie eine `WHERE` Klausel an das Ende unserer `SELECT` Anweisung anhängen.
**Um eine Teilmenge von Zeilen abzufragen**
1. Öffnen Sie Amazon Keyspaces AWS CloudShell und stellen Sie mithilfe des folgenden Befehls eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Führen Sie die folgende Abfrage aus, um nur die Datensätze für die Auszeichnungen eines bestimmten Jahres abzurufen.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Wolf' ;
```
Die vorherige `SELECT` Anweisung gibt die folgende Ausgabe zurück.
```
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
```
### Die `WHERE` Klausel verstehen
Die `WHERE` Klausel wird verwendet, um die Daten zu filtern und nur die Daten zurückzugeben, die die angegebenen Kriterien erfüllen. Bei den angegebenen Kriterien kann es sich um eine einfache oder eine zusammengesetzte Bedingung handeln.
**Wie verwendet man Bedingungen in einer `WHERE` Klausel**
+ Eine einfache Bedingung — Eine einzelne Spalte.
```
WHERE column_name=value
```
Sie können eine einfache Bedingung in einer `WHERE` Klausel verwenden, wenn eine der folgenden Bedingungen erfüllt ist:
+ Die Spalte ist die einzige Partitionsschlüsselspalte der Tabelle.
+ Sie fügen `ALLOW FILTERING` nach der Bedingung in der `WHERE` Klausel hinzu.
Beachten Sie, dass die Verwendung zu einer inkonsistenten Leistung führen `ALLOW FILTERING` kann, insbesondere bei großen und mehrfach partitionierten Tabellen.
+ Eine zusammengesetzte Bedingung — Mehrere einfache Bedingungen, die miteinander verbunden sind. `AND`
```
WHERE column_name1=value1 AND column_name2=value2 AND column_name3=value3...
```
Sie können zusammengesetzte Bedingungen in einer `WHERE` Klausel verwenden, wenn eine der folgenden Bedingungen erfüllt ist:
+ Die Spalten, die Sie in der `WHERE` Klausel verwenden können, müssen entweder alle oder eine Teilmenge der Spalten im Partitionsschlüssel der Tabelle enthalten. Wenn Sie nur eine Teilmenge der Spalten in der `WHERE` Klausel verwenden möchten, müssen Sie einen zusammenhängenden Satz von Partitionsschlüsselspalten von links nach rechts einbeziehen, beginnend mit der ersten Spalte des Partitionsschlüssels. Wenn die Partitionsschlüsselspalten beispielsweise `year``month`, und `award` dann können Sie die folgenden Spalten in der Klausel verwenden: `WHERE`
+ `year`
+ `year`UND `month`
+ `year`UND `month` UND `award`
+ Sie fügen `ALLOW FILTERING` nach der zusammengesetzten Bedingung in der `WHERE` Klausel hinzu, wie im folgenden Beispiel.
```
SELECT * FROM my_table WHERE col1=5 AND col2='Bob' ALLOW FILTERING ;
```
Beachten Sie, dass die Verwendung zu einer inkonsistenten Leistung führen `ALLOW FILTERING` kann, insbesondere bei großen und mehrfach partitionierten Tabellen.
### Probieren Sie es aus
Erstellen Sie Ihre eigenen CQL-Abfragen, um Folgendes aus Ihrer `book_awards` Tabelle zu ermitteln:
+ Finden Sie die Gewinner der Wolf Awards 2020 und zeigen Sie die Buchtitel und Autoren, sortiert nach Rang, an.
+ Zeigen Sie die Gewinner des ersten Preises für alle Auszeichnungen im Jahr 2020 an und zeigen Sie die Buchtitel und die Namen der Auszeichnungen an.
# Daten in einer Amazon Keyspaces-Tabelle mithilfe von CQL aktualisieren
Verwenden Sie die `UPDATE` Anweisung, um die Daten in Ihrer `book_awards` Tabelle zu aktualisieren.
Die allgemeine Form der `UPDATE` Aussage lautet wie folgt.
```
UPDATE table_name SET column_name=new_value WHERE primary_key=value ;
```
**Tipp**
Sie können mehrere Spalten aktualisieren, indem Sie eine kommagetrennte Liste von Werten `column_names` und verwenden, wie im folgenden Beispiel.
```
UPDATE my_table SET col1='new_value_1', col2='new_value2' WHERE col3='1' ;
```
Wenn der Primärschlüssel aus mehreren Spalten besteht, müssen alle Primärschlüsselspalten und ihre Werte in der `WHERE` Klausel enthalten sein.
Sie können keine Spalte im Primärschlüssel aktualisieren, da dies den Primärschlüssel für den Datensatz ändern würde.
**Um eine einzelne Zelle zu aktualisieren**
Ändern Sie anhand Ihrer `book_awards` Tabelle den Namen eines Verlegers, der 2020 mit dem Sachbuchpreis Wolf ausgezeichnet wurde.
```
UPDATE book_awards SET publisher='new Books' WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
Vergewissern Sie sich, dass der Herausgeber es jetzt `new Books` ist.
```
SELECT * FROM book_awards WHERE year = 2020 AND award='Wolf' AND category='Non-Fiction' AND rank=1;
```
Die Anweisung sollte die folgende Ausgabe zurückgeben.
```
year | award | category | rank | author | book_title | publisher
------+-------+-------------+------+-------------+------------------+-----------
2020 | Wolf | Non-Fiction | 1 | Wang Xiulan | History of Ideas | new Books
```
## Versuche es
**Fortgeschritten:** Der Gewinner des „Kwezi Manu Prize“ für Belletristik 2020 hat seinen Namen geändert. Aktualisieren Sie diesen Datensatz, um den Namen in zu ändern. `'Akua Mansa-House'`
# Löschen Sie Daten aus einer Tabelle mithilfe der CQL-Anweisung `DELETE`
Verwenden Sie die Anweisung, um Daten in Ihrer `book_awards` Tabelle zu löschen. `DELETE`
Sie können Daten aus einer Zeile oder aus einer Partition löschen. Seien Sie vorsichtig beim Löschen von Daten, da Löschungen irreversibel sind.
Durch das Löschen einer oder aller Zeilen aus einer Tabelle wird die Tabelle nicht gelöscht. Somit können Sie sie erneut mit Daten füllen. Durch das Löschen einer Tabelle werden die Tabelle und alle darin enthaltenen Daten gelöscht. Um die Tabelle wieder verwenden zu können, müssen Sie sie neu erstellen und ihr Daten hinzufügen. Durch das Löschen eines Schlüsselraums werden der Schlüsselraum und alle darin enthaltenen Tabellen gelöscht. Um den Schlüsselraum und die Tabellen verwenden zu können, müssen Sie sie neu erstellen und sie dann mit Daten füllen. Sie können die Wiederherstellung mit Amazon Keyspaces Point-in-time (PITR) verwenden, um gelöschte Tabellen wiederherzustellen. Weitere Informationen finden Sie unter. [Daten mit point-in-time Wiederherstellung für Amazon Keyspaces Backup und wiederherstellen](PointInTimeRecovery.md) Informationen zum Wiederherstellen einer gelöschten Tabelle mit aktiviertem PITR finden Sie unter. [Eine gelöschte Tabelle mit Amazon Keyspaces PITR wiederherstellen](restoredeleted.md)
## Zellen löschen
Beim Löschen einer Spalte aus einer Zeile werden die Daten aus der angegebenen Zelle entfernt. Wenn Sie diese Spalte mithilfe einer `SELECT` Anweisung anzeigen, werden die Daten als angezeigt*null*, obwohl an dieser Stelle kein Nullwert gespeichert ist.
Die allgemeine Syntax zum Löschen einer oder mehrerer bestimmter Spalten lautet wie folgt.
```
DELETE column_name1[, column_name2...] FROM table_name WHERE condition ;
```
In Ihrer `book_awards` Tabelle können Sie sehen, dass der Titel des Buches, das den ersten Preis des „Richard Roe“ -Preises 2020 gewonnen hat, „Long Summer“ lautet. Stellen Sie sich vor, dieser Titel wurde zurückgerufen und Sie müssen die Daten aus dieser Zelle löschen.
**Um eine bestimmte Zelle zu löschen**
1. Öffnen Sie Amazon Keyspaces AWS CloudShell und stellen Sie mithilfe des folgenden Befehls eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Führen Sie die folgende `DELETE` Abfrage aus.
```
DELETE book_title FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Stellen Sie sicher, dass die Löschanforderung wie erwartet gestellt wurde.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
Die Ausgabe dieser Anweisung sieht wie folgt aus.
```
year | award | category | rank | author | book_title | publisher
------+-------------+----------+------+-------------------+------------+---------------
2020 | Richard Roe | Fiction | 1 | Alejandro Rosalez | null | SomePublisher
```
## Zeilen löschen
Es kann vorkommen, dass Sie eine ganze Zeile löschen müssen, um beispielsweise einer Anfrage zur Datenlöschung nachzukommen. Die allgemeine Syntax für das Löschen einer Zeile lautet wie folgt.
```
DELETE FROM table_name WHERE condition ;
```
**Um eine Zeile zu löschen**
1. Öffnen Sie Amazon Keyspaces AWS CloudShell und stellen Sie mithilfe des folgenden Befehls eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Führen Sie die folgende `DELETE` Abfrage aus.
```
DELETE FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
1. Stellen Sie sicher, dass der Löschvorgang wie erwartet durchgeführt wurde.
```
SELECT * FROM catalog.book_awards WHERE year=2020 AND award='Richard Roe' AND category='Fiction' AND rank=1;
```
Die Ausgabe dieser Anweisung sieht nach dem Löschen der Zeile wie folgt aus.
```
year | award | category | rank | author | book_title | publisher
------+-------+----------+------+--------+------------+-----------
(0 rows)
```
Mit Amazon Keyspaces Time to Live können Sie abgelaufene Daten automatisch aus Ihrer Tabelle löschen. Weitere Informationen finden Sie unter[Daten mit Time to Live (TTL) für Amazon Keyspaces (für Apache Cassandra) ablaufen lassen](TTL.md).
# Löschen Sie eine Tabelle in Amazon Keyspaces
Um zu vermeiden, dass Ihnen für Tabellen und Daten, die Sie nicht benötigen, Gebühren berechnet werden, löschen Sie alle Tabellen, die Sie nicht verwenden. Wenn Sie eine Tabelle löschen, werden die Tabelle und ihre Daten gelöscht, und es fallen keine Gebühren mehr für sie an. Der Schlüsselraum bleibt jedoch bestehen. Wenn Sie einen Schlüsselraum löschen, werden der Schlüsselraum und alle zugehörigen Tabellen gelöscht, und es fallen keine Gebühren mehr für ihn an.
Sie können eine Tabelle mit der Konsole, CQL oder dem löschen. AWS CLI Wenn Sie eine Tabelle löschen, werden die Tabelle und alle ihre Daten gelöscht.
## Verwenden der Konsole
Das folgende Verfahren löscht eine Tabelle und alle ihre Daten mithilfe von. AWS-Managementkonsole
**Um eine Tabelle mit der Konsole zu löschen**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Keyspaces-Konsole zu [https://console.aws.amazon.com/keyspaces/Hause](https://console.aws.amazon.com/keyspaces/home).
1. Wählen Sie im Navigationsbereich **Tables** (Tabellen) aus.
1. Wählen Sie das Feld links neben dem Namen jeder Tabelle aus, die Sie löschen möchten.
1. Wählen Sie **Löschen** aus.
1. Geben Sie auf dem Bildschirm **Tabelle löschen** den Text **Delete** in das Feld ein. Wählen Sie dann **Tabelle löschen**.
1. Um zu überprüfen, ob die Tabelle gelöscht wurde, wählen Sie im Navigationsbereich **Tabellen** aus und vergewissern Sie sich, dass die `book_awards` Tabelle nicht mehr aufgeführt ist.
## Verwenden von CQL
Das folgende Verfahren löscht eine Tabelle und all ihre Daten mithilfe von CQL.
**Um eine Tabelle mit CQL zu löschen**
1. Öffnen Sie Amazon Keyspaces AWS CloudShell und stellen Sie mithilfe des folgenden Befehls eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Löschen Sie Ihre Tabelle, indem Sie die folgende Anweisung eingeben.
```
DROP TABLE IF EXISTS catalog.book_awards ;
```
1. Vergewissern Sie sich, dass Ihre Tabelle gelöscht wurde.
```
SELECT * FROM system_schema.tables WHERE keyspace_name = 'catalog' ;
```
Die Ausgabe sollte so aussehen. Beachten Sie, dass dies einige Zeit dauern kann. Führen Sie die Anweisung daher nach einer Minute erneut aus, wenn Sie dieses Ergebnis nicht sehen.
```
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)
```
## Verwenden Sie AWS CLI
Das folgende Verfahren löscht eine Tabelle und all ihre Daten mithilfe von. AWS CLI
**Um eine Tabelle mit dem zu löschen AWS CLI**
1. Öffnen CloudShell
1. Löschen Sie Ihre Tabelle mit der folgenden Anweisung.
```
aws keyspaces delete-table --keyspace-name 'catalog' --table-name 'book_awards'
```
1. Um zu überprüfen, ob Ihre Tabelle gelöscht wurde, können Sie alle Tabellen in einem Schlüsselraum auflisten.
```
aws keyspaces list-tables --keyspace-name 'catalog'
```
Die Ausgabe sollte folgendermaßen aussehen. Beachten Sie, dass dieser asynchrone Vorgang einige Zeit in Anspruch nehmen kann. Führen Sie den Befehl nach kurzer Zeit erneut aus, um zu bestätigen, dass die Tabelle gelöscht wurde.
```
{
"tables": []
}
```
# Löschen Sie einen Schlüsselraum in Amazon Keyspaces
Um zu vermeiden, dass Ihnen für Schlüsselräume Gebühren berechnet werden, löschen Sie alle Schlüsselräume, die Sie nicht verwenden. Wenn Sie einen Schlüsselraum löschen, werden der Schlüsselraum und alle zugehörigen Tabellen gelöscht, und es fallen keine Gebühren mehr für sie an.
Sie können einen Schlüsselraum entweder mit der Konsole, CQL oder dem löschen. AWS CLI
## Verwenden der Konsole
Das folgende Verfahren löscht einen Schlüsselraum und alle zugehörigen Tabellen und Daten mithilfe der Konsole.
**Um einen Schlüsselraum mit der Konsole zu löschen**
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon Keyspaces-Konsole zu [https://console.aws.amazon.com/keyspaces/Hause](https://console.aws.amazon.com/keyspaces/home).
1. Wählen Sie im Navigationsbereich **Keyspaces** aus.
1. Wählen Sie das Feld links neben dem Namen jedes Schlüsselraums aus, den Sie löschen möchten.
1. Wählen Sie **Löschen** aus.
1. Geben Sie auf dem Bildschirm **„Schlüsselraum löschen**“ **Delete** in das Feld ein. Wählen Sie dann „**Schlüsselraum löschen“**.
1. Um zu überprüfen, ob der Schlüsselraum gelöscht `catalog` wurde, wählen Sie im Navigationsbereich **Keyspaces** aus und vergewissern Sie sich, dass er nicht mehr aufgeführt ist. Da Sie den Schlüsselraum gelöscht haben, sollte die `book_awards` Tabelle unter **Tabellen** ebenfalls nicht aufgeführt werden.
## Verwenden von CQL
Das folgende Verfahren löscht einen Schlüsselraum und all seine Tabellen und Daten mithilfe von CQL.
**Um einen Schlüsselraum mit CQL zu löschen**
1. Öffnen Sie Amazon Keyspaces AWS CloudShell und stellen Sie mithilfe des folgenden Befehls eine Verbindung zu Amazon Keyspaces her. Stellen Sie sicher, dass Sie *us-east-1* mit Ihrer eigenen Region aktualisieren.
```
cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
```
1. Löschen Sie Ihren Schlüsselraum, indem Sie die folgende Anweisung eingeben.
```
DROP KEYSPACE IF EXISTS catalog ;
```
1. Vergewissern Sie sich, dass Ihr Schlüsselraum gelöscht wurde.
```
SELECT * from system_schema.keyspaces ;
```
Ihr Keyspace sollte nicht aufgeführt werden. Beachten Sie, dass es zu Verzögerungen kommen kann, bis der Schlüsselraum gelöscht wird, da es sich um einen asynchronen Vorgang handelt. Nachdem der Schlüsselraum gelöscht wurde, sollte die Ausgabe der Anweisung wie folgt aussehen.
```
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)
```
## Mit dem AWS CLI
Das folgende Verfahren löscht einen Schlüsselraum und alle zugehörigen Tabellen und Daten mithilfe von. AWS CLI
**Um einen Schlüsselraum mit dem zu löschen AWS CLI**
1. Öffnen AWS CloudShell
1. Löschen Sie Ihren Keyspace, indem Sie die folgende Anweisung eingeben.
```
aws keyspaces delete-keyspace --keyspace-name 'catalog'
```
1. Vergewissern Sie sich, dass Ihr Schlüsselraum gelöscht wurde.
```
aws keyspaces list-keyspaces
```
Die Ausgabe dieser Anweisung sollte in etwa so aussehen und nur die Systemschlüsselräume auflisten. Beachten Sie, dass es zu Verzögerungen kommen kann, bis Ihr Schlüsselraum gelöscht wird, da es sich um einen asynchronen Vorgang handelt.
```
{
"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"
}
]
}
```