Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Istruzioni DML (linguaggio di manipolazione dei dati) in Amazon Keyspaces
<a name="cql.dml"></a>

Il *linguaggio di manipolazione dei dati* (DML) è l'insieme di istruzioni Cassandra Query Language (CQL) che usi per gestire i dati nelle tabelle Amazon Keyspaces (per Apache Cassandra). Le istruzioni DML vengono utilizzate per aggiungere, modificare o eliminare i dati in una tabella.

Utilizzi anche istruzioni DML per interrogare i dati in una tabella. (Nota che CQL non supporta join o sottoquery.)

**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>

Utilizzare un'istruzione SELECT per interrogare i dati. 

**Sintassi**

```
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 ] )*
```

**Esempi**

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

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

Per una tabella che mappa i tipi di dati con codifica JSON ai tipi di dati Amazon Keyspaces, consulta. [Codifica JSON dei tipi di dati Amazon Keyspaces](cql.elements.md#cql.data-types.JSON)

**Utilizzo della parola chiave `IN`**

La `IN` parola chiave specifica l'uguaglianza per uno o più valori. Può essere applicata alla chiave di partizione e alla colonna di clustering. I risultati vengono restituiti nell'ordine in cui le chiavi sono presentate nell'`SELECT`istruzione.

**Esempi**

```
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;
```

Per ulteriori informazioni sulla `IN` parola chiave e su come Amazon Keyspaces elabora l'istruzione, consulta. [Usa l'`IN`operatore con l'`SELECT`istruzione in una query in Amazon Keyspaces](in.select.md)

**Ordinamento dei risultati**

La `ORDER BY` clausola specifica l'ordinamento dei risultati restituiti. Prende come argomenti un elenco di nomi di colonna insieme all'ordinamento per ogni colonna. È possibile specificare le colonne di raggruppamento solo nelle clausole di ordinamento. Le colonne non raggruppate non sono consentite. Le opzioni di ordinamento sono `ASC` per l'ordinamento crescente e `DESC` per l'ordinamento decrescente. Se l'ordinamento viene omesso, viene utilizzato l'ordinamento predefinito della colonna di raggruppamento. Per i possibili tipi di ordinamento, vedere. [Ordina i risultati con `ORDER BY` in Amazon Keyspaces](ordering-results.md)

**Esempio**

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

Quando si utilizza `ORDER BY` con la `IN` parola chiave, i risultati vengono ordinati all'interno di una pagina. Il riordino completo con impaginazione disabilitata non è supportato.

**TOKEN**

È possibile applicare la `TOKEN` funzione alla `PARTITION KEY` colonna `SELECT` e alle `WHERE` clausole. Con la `TOKEN` funzione, Amazon Keyspaces restituisce le righe in base al valore del token mappato di `PARTITION_KEY` anziché al valore di. `PARTITION KEY`

`TOKEN`le relazioni non sono supportate con la `IN` parola chiave.

**Esempi**

```
SELECT TOKEN(id) from my_table; 

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

**funzione TTL**

È possibile utilizzare la `TTL` funzione con l'`SELECT`istruzione per recuperare il tempo di scadenza in secondi memorizzato per una colonna. Se non è impostato alcun `TTL` valore, la funzione restituisce`null`.

**Esempio**

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

La `TTL` funzione non può essere utilizzata su colonne a celle multiple come le raccolte.

**Funzione WRITETIME**

È possibile utilizzare la `WRITETIME` funzione con l'`SELECT`istruzione per recuperare il timestamp archiviato come metadati per il valore di una colonna solo se la tabella utilizza timestamp sul lato client. Per ulteriori informazioni, consulta [Timestamp lato client in Amazon Keyspaces](client-side-timestamps.md). 

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

La `WRITETIME` funzione non può essere utilizzata su colonne a celle multiple come le raccolte.

**Nota**  
Per motivi di compatibilità con il comportamento consolidato dei driver Cassandra, le politiche di autorizzazione basate su tag non vengono applicate quando si eseguono operazioni sulle tabelle di sistema utilizzando le chiamate API Cassandra Query Language (CQL) tramite i driver Cassandra e gli strumenti di sviluppo. Per ulteriori informazioni, consulta [Accesso alle risorse Amazon Keyspaces basato su tag](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-tags).

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

Utilizzate l'`INSERT`istruzione per aggiungere una riga a una tabella.

**Sintassi**

```
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 )* ')'
```

**Esempio**

```
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') ;
```

**Aggiorna i parametri**

`INSERT`supporta i seguenti valori come`update_parameter`:
+ `TTL`— Un valore temporale in secondi. Il valore massimo configurabile è 630.720.000 secondi, che equivale a 20 anni.
+ `TIMESTAMP`— Un `bigint` valore che rappresenta il numero di microsecondi dall'ora base standard nota comeepoch: 1° gennaio 1970 alle 00:00:00 GMT. Un timestamp in Amazon Keyspaces deve essere compreso tra 2 giorni passati e 5 minuti futuri.

**Esempio**

```
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;
```

**Supporto JSON**

Per una tabella che mappa i tipi di dati con codifica JSON ai tipi di dati Amazon Keyspaces, consulta. [Codifica JSON dei tipi di dati Amazon Keyspaces](cql.elements.md#cql.data-types.JSON)

Puoi usare la `JSON` parola chiave per inserire una mappa con `JSON` codifica in una singola riga. Per le colonne che esistono nella tabella ma sono omesse nell'istruzione JSON insert, utilizza `DEFAULT UNSET` per preservare i valori esistenti. `DEFAULT NULL`Utilizzatelo per scrivere un valore NULL in ogni riga di colonne omesse e sovrascrivere i valori esistenti (si applicano le tariffe di scrittura standard). `DEFAULT NULL`è l'opzione predefinita.

**Esempio**

```
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"}';
```

Se i dati JSON contengono chiavi duplicate, Amazon Keyspaces memorizza l'ultimo valore per la chiave (simile a Apache Cassandra). Nell'esempio seguente, dove si trova la chiave duplicata, viene `id` utilizzato il valore. `234-56-7890`

**Esempio**

```
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>

Utilizzate l'`UPDATE`istruzione per modificare una riga in una tabella.

**Sintassi**

```
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
```

**Esempio**

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

Per incrementare a`counter`, utilizzare la seguente sintassi. Per ulteriori informazioni, consulta [Contatori](cql.elements.md#cql.data-types.numeric.counters).

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

**Aggiorna i parametri**

`UPDATE`supporta i seguenti valori come`update_parameter`:
+ `TTL`— Un valore temporale in secondi. Il valore massimo configurabile è 630.720.000 secondi, che equivale a 20 anni.
+ `TIMESTAMP`— Un `bigint` valore che rappresenta il numero di microsecondi dall'ora base standard nota comeepoch: 1° gennaio 1970 alle 00:00:00 GMT. Un timestamp in Amazon Keyspaces deve essere compreso tra 2 giorni passati e 5 minuti futuri.

**Esempio**

```
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>

Utilizzate l'`DELETE`istruzione per rimuovere una riga da una tabella.

**Sintassi**

```
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
```

Dove:
+ `table_name`è la tabella che contiene la riga che si desidera eliminare.

**Esempio**

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

`DELETE`supporta il seguente valore come`update_parameter`:
+ `TIMESTAMP`— Un `bigint` valore che rappresenta il numero di microsecondi trascorsi dall'ora base standard nota comeepoch: 1° gennaio 1970 alle 00:00:00 GMT.