

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.

# DML-Anweisungen (Datenmanipulationssprache) in Amazon Keyspaces
<a name="cql.dml"></a>

*Data Manipulation Language* (DML) ist der Satz von Cassandra Query Language (CQL) -Anweisungen, mit denen Sie Daten in Amazon Keyspaces-Tabellen (für Apache Cassandra) verwalten. Sie verwenden DML-Anweisungen, um Daten in einer Tabelle hinzuzufügen, zu ändern oder zu löschen.

Sie verwenden DML-Anweisungen auch, um Daten in einer Tabelle abzufragen. (Beachten Sie, dass CQL keine Verknüpfungen oder Unterabfragen unterstützt.)

**Topics**
+ [SELECT](cql.dml.select.md)
+ [INSERT](cql.dml.insert.md)
+ [UPDATE](cql.dml.update.md)
+ [DELETE](cql.dml.delete.md)

# SELECT
<a name="cql.dml.select"></a>

Verwenden Sie eine SELECT-Anweisung, um Daten abzufragen. 

**Syntax**

```
select_statement ::=  SELECT  [ JSON ] ( select_clause | '*' )
                      FROM table_name
                      [ WHERE 'where_clause' ]
                      [ ORDER BY 'ordering_clause' ]
                      [ LIMIT (integer | bind_marker) ]
                      [ ALLOW FILTERING ]
select_clause    ::=  selector [ AS identifier ] ( ',' selector [ AS identifier ] )
selector         ::=  column_name
                      | term
                      | CAST '(' selector AS cql_type ')'
                      | function_name '(' [ selector ( ',' selector )* ] ')'
where_clause     ::=  relation ( AND relation )*
relation         ::=  column_name operator term
                      TOKEN
operator         ::=  '=' | '<' | '>' | '<=' | '>=' | IN | CONTAINS | CONTAINS KEY
ordering_clause  ::=  column_name [ ASC | DESC ] ( ',' column_name [ ASC | DESC ] )*
```

**Beispiele**

```
SELECT name, id, manager_id FROM "myGSGKeyspace".employees_tbl ;

SELECT JSON name, id, manager_id FROM "myGSGKeyspace".employees_tbl ;
```

Eine Tabelle, die JSON-kodierte Datentypen Amazon Keyspaces-Datentypen zuordnet, finden Sie unter. [JSON-Kodierung von Amazon Keyspaces-Datentypen](cql.elements.md#cql.data-types.JSON)

**Verwenden Sie das Schlüsselwort `IN`**

Das `IN` Schlüsselwort gibt die Gleichheit für einen oder mehrere Werte an. Es kann auf den Partitionsschlüssel und die Clusterspalte angewendet werden. Die Ergebnisse werden in der Reihenfolge zurückgegeben, in der die Schlüssel in der `SELECT` Anweisung dargestellt werden.

**Beispiele**

```
SELECT * from mykeyspace.mytable WHERE primary.key1 IN (1,2) and clustering.key1 = 2;
SELECT * from mykeyspace.mytable WHERE primary.key1 IN (1,2) and clustering.key1 <= 2;
SELECT * from mykeyspace.mytable WHERE primary.key1 = 1 and clustering.key1 IN (1, 2);
SELECT * from mykeyspace.mytable WHERE primary.key1 <= 2 and clustering.key1 IN (1, 2) ALLOW FILTERING;
```

Weitere Informationen zum `IN` Schlüsselwort und zur Verarbeitung der Anweisung durch Amazon Keyspaces finden Sie unter[Verwenden Sie den `IN` Operator mit der `SELECT` Anweisung in einer Abfrage in Amazon Keyspaces](in.select.md).

**Ergebnisse bestellen**

Die `ORDER BY` Klausel gibt die Sortierreihenfolge der zurückgegebenen Ergebnisse an. Sie verwendet als Argumente eine Liste von Spaltennamen zusammen mit der Sortierreihenfolge für jede Spalte. Sie können Clusterspalten nur in Sortierklauseln angeben. Spalten, bei denen es sich nicht um Gruppierungen handelt, sind nicht zulässig. Die Optionen für die Sortierreihenfolge gelten `ASC` für die aufsteigende und `DESC` für die absteigende Sortierreihenfolge. Wenn die Sortierreihenfolge weggelassen wird, wird die Standardreihenfolge der Clusterspalte verwendet. Mögliche Sortierreihenfolgen finden Sie unter[Ergebnisse `ORDER BY` in Amazon Keyspaces bestellen](ordering-results.md).

**Beispiel**

```
SELECT name, id, division, manager_id FROM "myGSGKeyspace".employees_tbl WHERE id = '012-34-5678' ORDER BY division;
```

Bei Verwendung `ORDER BY` mit dem `IN` Schlüsselwort werden die Ergebnisse innerhalb einer Seite angeordnet. Eine vollständige Neuanordnung mit deaktivierter Paginierung wird nicht unterstützt.

**TOKEN**

Sie können die `TOKEN` Funktion auf die `PARTITION KEY` Spalten in `SELECT` und `WHERE` -Klauseln anwenden. Mit dieser `TOKEN` Funktion gibt Amazon Keyspaces Zeilen zurück, die auf dem zugewiesenen Token-Wert von basieren `PARTITION_KEY` und nicht auf dem Wert von. `PARTITION KEY`

`TOKEN`Beziehungen werden mit dem Schlüsselwort nicht unterstützt. `IN`

**Beispiele**

```
SELECT TOKEN(id) from my_table; 

SELECT TOKEN(id) from my_table WHERE TOKEN(id) > 100 and TOKEN(id) < 10000;
```

**TTL-Funktion**

Sie können die `TTL` Funktion mit der `SELECT` Anweisung verwenden, um die für eine Spalte gespeicherte Ablaufzeit in Sekunden abzurufen. Wenn kein `TTL` Wert festgelegt ist, kehrt die Funktion zurück`null`.

**Beispiel**

```
SELECT TTL(my_column) from my_table;
```

Die `TTL` Funktion kann nicht für Spalten mit mehreren Zellen wie Sammlungen verwendet werden.

**WRITETIMEFunktion**

Sie können die `WRITETIME` Funktion mit der `SELECT` Anweisung nur dann verwenden, um den Zeitstempel abzurufen, der als Metadaten für den Wert einer Spalte gespeichert ist, wenn die Tabelle clientseitige Zeitstempel verwendet. Weitere Informationen finden Sie unter [Clientseitige Zeitstempel in Amazon Keyspaces](client-side-timestamps.md). 

```
SELECT WRITETIME(my_column) from my_table;
```

Die `WRITETIME` Funktion kann nicht für Spalten mit mehreren Zellen wie Sammlungen verwendet werden.

**Anmerkung**  
Aus Gründen der Kompatibilität mit dem gängigen Verhalten von Cassandra-Treibern werden tagbasierte Autorisierungsrichtlinien nicht durchgesetzt, wenn Sie mithilfe von Cassandra Query Language (CQL) -API-Aufrufen über Cassandra-Treiber und Entwicklertools Operationen an Systemtabellen ausführen. Weitere Informationen finden Sie unter [Amazon Keyspaces-Ressourcenzugriff basierend auf Tags](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-tags).

# INSERT
<a name="cql.dml.insert"></a>

Verwenden Sie die `INSERT` Anweisung, um einer Tabelle eine Zeile hinzuzufügen.

**Syntax**

```
insert_statement ::=  INSERT INTO table_name ( names_values | json_clause )
                      [ IF NOT EXISTS ]
                      [ USING update_parameter ( AND update_parameter )* ]
names_values     ::=  names VALUES tuple_literal
json_clause      ::=  JSON string [ DEFAULT ( NULL | UNSET ) ]                
names            ::=  '(' column_name ( ',' column_name )* ')'
```

**Beispiel**

```
INSERT INTO "myGSGKeyspace".employees_tbl (id, name, project, region, division, role, pay_scale, vacation_hrs, manager_id)
VALUES ('012-34-5678','Russ','NightFlight','US','Engineering','IC',3,12.5, '234-56-7890') ;
```

**Parameter aktualisieren**

`INSERT`unterstützt die folgenden Werte als`update_parameter`:
+ `TTL`— Ein Zeitwert in Sekunden. Der maximal konfigurierbare Wert ist 630 720 000 Sekunden, was 20 Jahren entspricht.
+ `TIMESTAMP`— Ein `bigint` Wert, der die Anzahl der Mikrosekunden seit der Standardbasiszeit darstellt, die alsepoch: 1. Januar 1970 um 00:00:00 Uhr GMT bekannt ist. Ein Zeitstempel in Amazon Keyspaces muss zwischen 2 Tagen in der Vergangenheit und 5 Minuten in der future liegen.

**Beispiel**

```
INSERT INTO my_table (userid, time, subject, body, user)
        VALUES (B79CB3BA-745E-5D9A-8903-4A02327A7E09, 96a29100-5e25-11ec-90d7-b5d91eceda0a, 'Message', 'Hello','205.212.123.123')
        USING TTL 259200;
```

**JSON-Unterstützung**

Eine Tabelle, die JSON-kodierte Datentypen Amazon Keyspaces-Datentypen zuordnet, finden Sie unter. [JSON-Kodierung von Amazon Keyspaces-Datentypen](cql.elements.md#cql.data-types.JSON)

Sie können das `JSON` Schlüsselwort verwenden, um eine `JSON` -kodierte Map als einzelne Zeile einzufügen. Verwenden Sie für Spalten, die in der Tabelle vorhanden sind, aber in der JSON-Einfügeanweisung weggelassen werden, `DEFAULT UNSET` um die vorhandenen Werte beizubehalten. Wird verwendet`DEFAULT NULL`, um in jede Zeile ausgelassener Spalten einen NULL-Wert zu schreiben und die vorhandenen Werte zu überschreiben (es fallen die üblichen Schreibgebühren an). `DEFAULT NULL`ist die Standardoption.

**Beispiel**

```
INSERT INTO "myGSGKeyspace".employees_tbl JSON '{"id":"012-34-5678",
                                                 "name": "Russ",
                                                 "project": "NightFlight",
                                                 "region": "US",
                                                 "division": "Engineering",
                                                 "role": "IC",
                                                 "pay_scale": 3,
                                                 "vacation_hrs": 12.5,
                                                 "manager_id": "234-56-7890"}';
```

Wenn die JSON-Daten doppelte Schlüssel enthalten, speichert Amazon Keyspaces den letzten Wert für den Schlüssel (ähnlich wie Apache Cassandra). Im folgenden Beispiel, in dem sich der doppelte Schlüssel befindet`id`, wird der Wert verwendet`234-56-7890`.

**Beispiel**

```
INSERT INTO "myGSGKeyspace".employees_tbl JSON '{"id":"012-34-5678",
                                                 "name": "Russ",
                                                 "project": "NightFlight",
                                                 "region": "US",
                                                 "division": "Engineering",
                                                 "role": "IC",
                                                 "pay_scale": 3,
                                                 "vacation_hrs": 12.5,
                                                 "id": "234-56-7890"}';
```

# UPDATE
<a name="cql.dml.update"></a>

Verwenden Sie die `UPDATE` Anweisung, um eine Zeile in einer Tabelle zu ändern.

**Syntax**

```
update_statement ::=  UPDATE table_name
                      [ USING update_parameter ( AND update_parameter )* ]
                      SET assignment ( ',' assignment )*
                      WHERE where_clause
                      [ IF ( EXISTS | condition ( AND condition )*) ]
update_parameter ::=  ( integer | bind_marker )
assignment       ::=  simple_selection '=' term
                     | column_name '=' column_name ( '+' | '-' ) term
                     | column_name '=' list_literal '+' column_name
simple_selection ::=  column_name
                     | column_name '[' term ']'
                     | column_name '.' `field_name
condition        ::=  simple_selection operator term
```

**Beispiel**

```
UPDATE "myGSGKeyspace".employees_tbl SET pay_scale = 5 WHERE id = '567-89-0123' AND division = 'Marketing' ;
```

Verwenden Sie die folgende Syntax`counter`, um a zu inkrementieren. Weitere Informationen finden Sie unter [Zähler](cql.elements.md#cql.data-types.numeric.counters).

```
UPDATE ActiveUsers SET counter = counter + 1  WHERE user = A70FE1C0-5408-4AE3-BE34-8733E5K09F14 AND action = 'click';
```

**Parameter aktualisieren**

`UPDATE`unterstützt die folgenden Werte als`update_parameter`:
+ `TTL`— Ein Zeitwert in Sekunden. Der maximal konfigurierbare Wert ist 630 720 000 Sekunden, was 20 Jahren entspricht.
+ `TIMESTAMP`— Ein `bigint` Wert, der die Anzahl der Mikrosekunden seit der Standardbasiszeit darstellt, die alsepoch: 1. Januar 1970 um 00:00:00 Uhr GMT bekannt ist. Ein Zeitstempel in Amazon Keyspaces muss zwischen 2 Tagen in der Vergangenheit und 5 Minuten in der future liegen.

**Beispiel**

```
UPDATE my_table (userid, time, subject, body, user)
        VALUES (B79CB3BA-745E-5D9A-8903-4A02327A7E09, 96a29100-5e25-11ec-90d7-b5d91eceda0a, 'Message', 'Hello again','205.212.123.123')
        USING TIMESTAMP '2022-11-03 13:30:54+0400';
```

# DELETE
<a name="cql.dml.delete"></a>

Verwenden Sie die `DELETE` Anweisung, um eine Zeile aus einer Tabelle zu entfernen.

**Syntax**

```
delete_statement ::=  DELETE [ simple_selection ( ',' simple_selection ) ]
                      FROM table_name
                      [ USING update_parameter ( AND update_parameter )* ]
                      WHERE where_clause
                      [ IF ( EXISTS | condition ( AND condition )*) ]

simple_selection ::=  column_name
                     | column_name '[' term ']'
                     | column_name '.' `field_name

condition        ::=  simple_selection operator term
```

Wobei Folgendes gilt:
+ `table_name`ist die Tabelle, die die Zeile enthält, die Sie löschen möchten.

**Beispiel**

```
DELETE manager_id FROM "myGSGKeyspace".employees_tbl WHERE id='789-01-2345' AND division='Executive' ;
```

`DELETE`unterstützt den folgenden Wert als`update_parameter`:
+ `TIMESTAMP`— Ein `bigint` Wert, der die Anzahl der Mikrosekunden seit der Standardbasiszeit darstellt, die alsepoch: 1. Januar 1970 um 00:00:00 GMT bekannt ist.