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.
# 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).