

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à.

# Riferimento al linguaggio CQL per Amazon Keyspaces (per Apache Cassandra)
<a name="cql"></a>

Dopo esserti connesso a un endpoint Amazon Keyspaces, usi Cassandra Query Language (CQL) per lavorare con il tuo database. CQL è simile in molti modi a Structured Query Language (SQL).
+ **Elementi CQL**: questa sezione tratta gli elementi fondamentali di CQL supportati in Amazon Keyspaces, inclusi identificatori, costanti, termini e tipi di dati. Spiega concetti come tipi di stringhe, tipi numerici, tipi di raccolta e altro ancora. 
+ **Data Definition Language (DDL)**: le istruzioni DDL vengono utilizzate per gestire strutture di dati come keyspace e tabelle in Amazon Keyspaces. Questa sezione descrive le istruzioni per la creazione, la modifica e l'eliminazione di keyspace e tabelle, nonché per il ripristino delle tabelle da un backup. point-in-time 
+ **Data Manipulation Language (DML): le istruzioni DML** vengono utilizzate per gestire i dati all'interno delle tabelle. Questa sezione descrive le istruzioni per la selezione, l'inserimento, l'aggiornamento e l'eliminazione dei dati. Spiega inoltre funzionalità di interrogazione avanzate come l'utilizzo `IN` dell'operatore, l'ordinamento dei risultati e l'impaginazione. 
+ **Funzioni integrate**: Amazon Keyspaces supporta una varietà di funzioni scalari integrate che puoi utilizzare nelle istruzioni CQL. Questa sezione fornisce una panoramica di queste funzioni, inclusi esempi del loro utilizzo. 

In questo argomento, troverai sintassi dettagliate, esempi e best practice per utilizzare CQL in modo efficace in Amazon Keyspaces.

**Topics**
+ [Elementi del Cassandra Query Language (CQL) in Amazon Keyspaces](cql.elements.md)
+ [Istruzioni DDL (linguaggio di definizione dei dati) in Amazon Keyspaces](cql.ddl.md)
+ [Istruzioni DML (linguaggio di manipolazione dei dati) in Amazon Keyspaces](cql.dml.md)
+ [Funzioni integrate in Amazon Keyspaces](cql.functions.md)

# Elementi del Cassandra Query Language (CQL) in Amazon Keyspaces
<a name="cql.elements"></a>

Scopri gli elementi del Cassandra Query Language (CQL) supportati da Amazon Keyspaces, inclusi identificatori, costanti, termini e tipi di dati.

**Topics**
+ [identifier](#cql.elements.identifier)
+ [constants](#cql.elements.constants)
+ [term](#cql.elements.term)
+ [Tipi di dati](#cql.data-types)
+ [Codifica JSON dei tipi di dati Amazon Keyspaces](#cql.data-types.JSON)

## Identificatori
<a name="cql.elements.identifier"></a>

Gli identificatori (o nomi) vengono utilizzati per identificare tabelle, colonne e altri oggetti. Un identificatore può essere citato o non citato. Si applica quanto segue.

```
identifier          ::=  unquoted_identifier | quoted_identifier
unquoted_identifier ::=  re('[a-zA-Z][a-zA-Z0-9_]*')
quoted_identifier   ::=  '"' (any character where " can appear if doubled)+ '"'
```

## Costanti
<a name="cql.elements.constants"></a>

Sono definite le seguenti costanti.

```
constant ::=  string | integer | float | boolean | uuid | blob | NULL
string   ::=  '\'' (any character where ' can appear if doubled)+ '\''
              '$$' (any character other than '$$') '$$'
integer  ::=  re('-?[0-9]+')
float    ::=  re('-?[0-9]+(\.[0-9]*)?([eE][+-]?[0-9+])?') | NAN | INFINITY
boolean  ::=  TRUE | FALSE
uuid     ::=  hex{8}-hex{4}-hex{4}-hex{4}-hex{12}
hex      ::=  re("[0-9a-fA-F]")
blob     ::=  '0' ('x' | 'X') hex+
```

## Termini
<a name="cql.elements.term"></a>

Un termine indica il tipo di valori supportati. I termini sono definiti come segue.

```
term                 ::=  constant | literal | function_call | arithmetic_operation | type_hint | bind_marker
literal              ::=  collection_literal | tuple_literal
function_call        ::=  identifier '(' [ term (',' term)* ] ')'
arithmetic_operation ::=  '-' term | term ('+' | '-' | '*' | '/' | '%') term
```

## Tipi di dati
<a name="cql.data-types"></a>

Amazon Keyspaces supporta i seguenti tipi di dati:

### Tipo stringa
<a name="cql.data-types.string"></a>


****  

| Tipo di dati | Description | 
| --- | --- | 
|  `ascii`  | Rappresenta una stringa di caratteri ASCII. | 
|  `text`  | Rappresenta una stringa con codifica UTF-8. | 
|  `varchar`  |  Rappresenta una stringa con codifica UTF-8 (è un alias per)`varchar`. `text`  | 

### Tipi numerici
<a name="cql.data-types.numeric"></a>


****  

| Tipo di dati | Description | 
| --- | --- | 
|  `bigint`  | Rappresenta un valore long firmato a 64 bit. | 
|  `counter`  | Rappresenta un contatore intero con segno a 64 bit. Per ulteriori informazioni, consulta [Contatori](#cql.data-types.numeric.counters). | 
|  `decimal`  | Rappresenta un decimale a precisione variabile. | 
|  `double`  | Rappresenta una virgola mobile IEEE 754 a 64 bit. | 
|  `float`  | Rappresenta una virgola mobile IEEE 754 a 32 bit. | 
|  `int`  |  Rappresenta un int. firmato a 32 bit.  | 
|  `varint`  |  Rappresenta un valore intero compreso nell'intervallo \$1/-10^38.  | 

#### Contatori
<a name="cql.data-types.numeric.counters"></a>

Una `counter` colonna contiene un numero intero con segno a 64 bit. Il valore del contatore viene incrementato o diminuito utilizzando l'[UPDATE](cql.dml.update.md)istruzione e non può essere impostato direttamente. Ciò rende `counter` le colonne utili per tenere traccia dei conteggi. Ad esempio, puoi utilizzare i contatori per tenere traccia del numero di voci in un file di registro o del numero di volte in cui un post è stato visualizzato su un social network. Le seguenti restrizioni si applicano alle `counter` colonne:
+ Una colonna di tipo `counter` non può far parte `primary key` di una tabella.
+ In una tabella che contiene una o più colonne di tipo`counter`, tutte le colonne della tabella devono essere di tipo`counter`.

Nei casi in cui un controaggiornamento fallisce (ad esempio, a causa di timeout o perdita di connessione con Amazon Keyspaces), il client non sa se il valore del contatore è stato aggiornato. Se l'aggiornamento viene riprovato, l'aggiornamento al valore del contatore potrebbe essere applicato una seconda volta.

### Tipo di BLOB
<a name="cql.data-types.blob"></a>


****  

| Tipo di dati | Description | 
| --- | --- | 
|  `blob`  | Rappresenta byte arbitrari. | 

### Tipo booleano
<a name="cql.data-types.boolean"></a>


****  

| Tipo di dati | Description | 
| --- | --- | 
|  `boolean`  | Rappresenta true o. false | 

### Tipi relativi al tempo
<a name="cql.data-types.time"></a>


****  

| Tipo di dati | Description | 
| --- | --- | 
|  `date`  | Una stringa nel formato<yyyy>-<mm>-<dd>. | 
|  `timestamp`  | Numero intero con segno a 64 bit che rappresenta la data e l'ora dall'epoca (1° gennaio 1970 alle 00:00:00 GMT) in millisecondi. | 
|  `timeuuid`  | [Rappresenta](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)) un UUID della versione 1. | 

### Tipi di raccolta
<a name="cql.data-types.collection"></a>


****  

| Tipo di dati | Description | 
| --- | --- | 
|  `list`  | Rappresenta una raccolta ordinata di elementi letterali. | 
|  `map`  | Rappresenta una raccolta non ordinata di coppie chiave-valore. | 
|  `set`  | Rappresenta una raccolta non ordinata di uno o più elementi letterali. | 

Si dichiara una colonna di raccolta utilizzando il tipo di raccolta seguito da un altro tipo di dati (ad esempio `TEXT` o`INT`) tra parentesi angolate. È possibile creare una colonna con un `SET` of `TEXT` oppure creare una coppia `MAP` di `TEXT` e `INT` chiave-valore, come illustrato nell'esempio seguente.

```
SET <TEXT>
MAP <TEXT, INT>
```

Una raccolta *non congelata* consente di aggiornare ogni singolo elemento della raccolta. I timestamp sul lato client e le impostazioni Time to Live (TTL) vengono memorizzati per i singoli elementi.

Quando utilizzi la `FROZEN` parola chiave su un tipo di raccolta, i valori della raccolta vengono serializzati in un unico valore immutabile e Amazon Keyspaces li tratta come un. `BLOB` *Questa è una collezione congelata.* Un'`UPDATE`istruzione `INSERT` or sovrascrive l'intera raccolta congelata. Non è possibile aggiornare singoli elementi all'interno di una raccolta congelata.

I timestamp sul lato client e le impostazioni Time to Live (TTL) si applicano all'intera raccolta congelata, non ai singoli elementi. `Frozen`le colonne della raccolta possono far parte di una tabella. `PRIMARY KEY`

Puoi annidare raccolte congelate. Ad esempio, potete definire a `MAP` entro a `SET` se `MAP` sta utilizzando la `FROZEN` parola chiave, come illustrato nell'esempio seguente. 

```
SET <FROZEN> <MAP <TEXT, INT>>>
```

Amazon Keyspaces supporta l'annidamento di un massimo di 8 livelli di raccolte congelate per impostazione predefinita. Per ulteriori informazioni, consulta [Quote di servizio Amazon Keyspaces](quotas.md#table). Per ulteriori informazioni sulle differenze funzionali con Apache Cassandra, consulta. [`FROZEN`collezioni](functional-differences.md#functional-differences.frozen-collections) Per ulteriori informazioni sulla sintassi CQL, vedere e. [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create) [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter)

### Tipo di tupla
<a name="cql.data-types.tuple"></a>

Il tipo di `tuple` dati rappresenta un gruppo limitato di elementi letterali. Puoi usare una tupla come alternativa a. `user defined type` Non è necessario utilizzare la `FROZEN` parola chiave per le tuple. Questo perché una tupla è sempre bloccata e non è possibile aggiornare gli elementi singolarmente. 

### Altri tipi
<a name="cql.data-types.other"></a>


****  

| Tipo di dati | Description | 
| --- | --- | 
|  `inet`  | Una stringa che rappresenta un indirizzo IP, in uno dei due IPv4 IPv6 formati. | 

### Statico
<a name="cql.data-types.static"></a>

In una tabella Amazon Keyspaces con colonne di clustering, puoi utilizzare la `STATIC` parola chiave per creare una colonna statica di qualsiasi tipo. 

La seguente dichiarazione ne è un esempio.

```
my_column INT STATIC
```

Per ulteriori informazioni sull'utilizzo delle colonne statiche, vedere[Stima del consumo di capacità per le colonne statiche in Amazon Keyspaces](static-columns.md).

### Tipi definiti dall'utente () UDTs
<a name="cql.data-types.user-defined"></a>

Amazon Keyspaces supporta tipi definiti dall'utente (). UDTs Puoi utilizzare qualsiasi tipo di dati Amazon Keyspaces valido per creare un UDT, incluse raccolte e altri tipi esistenti. UDTs Puoi creare UDTs in un keyspace e puoi usarli per definire colonne in qualsiasi tabella nel keyspace.

Per ulteriori informazioni sulla sintassi CQL, vedere. [Tipi definiti dall'utente () UDTs](cql.ddl.type.md) Per ulteriori informazioni sull'utilizzo di UDTs, vedere. [Tipi definiti dall'utente (UDTs) in Amazon Keyspaces](udts.md)

Per verificare quanti UDTs sono supportati per keyspace, i livelli di nidificazione supportati e altri valori e quote predefiniti correlati, consulta. UDTs [Quote e valori predefiniti per i tipi definiti dall'utente (UDTs) in Amazon Keyspaces](quotas.md#quotas-udts)

## Codifica JSON dei tipi di dati Amazon Keyspaces
<a name="cql.data-types.JSON"></a>

Amazon Keyspaces offre le stesse mappature dei tipi di dati JSON di Apache Cassandra. La tabella seguente descrive i tipi di dati che Amazon Keyspaces accetta nelle `INSERT JSON` istruzioni e i tipi di dati utilizzati da Amazon Keyspaces quando restituisce dati con l'istruzione. `SELECT JSON`

Per tipi di dati a campo singolo come`float`,`int`, e `UUID``date`, puoi anche inserire dati come file. `string` Per i tipi di dati e le raccolte composti, ad esempio `tuple``map`, e`list`, puoi anche inserire dati come JSON o come codificati. `JSON string`


****  

| Tipo di dati JSON | Tipi di dati accettati nelle dichiarazioni `INSERT JSON` | Tipi di dati restituiti nelle `SELECT JSON` istruzioni | Note | 
| --- | --- | --- | --- | 
|  `ascii`  | string | string | Utilizza l'escape `\u` dei caratteri JSON. | 
|  `bigint`  | integer, string | integer | La stringa deve essere un numero intero valido a 64 bit. | 
|  `blob`  | string | string | La stringa deve iniziare con `0x` seguita da un numero pari di cifre esadecimali. | 
|  `boolean`  | boolean, string | boolean | La stringa deve essere una delle due opzioni`true`. `false` | 
|  `date`  | string | string | Formato della data`YYYY-MM-DD`, fuso orario UTC. | 
|  `decimal`  | integer, float, string | float | Può superare la precisione in virgola mobile IEEE-754 a 32 o 64 bit nel decoder lato client. | 
|  `double`  | integer, float, string | float | La stringa deve essere un numero intero o un float valido. | 
|  `float`  | integer, float, string | float | La stringa deve essere un numero intero o un float valido. | 
|  `inet`  | string | string | IPv4 o indirizzo. IPv6  | 
|  `int`  | integer, string | integer | La stringa deve essere un numero intero valido a 32 bit. | 
|  `list`  | list, string | list | Utilizza la rappresentazione nativa dell'elenco JSON. | 
|  `map`  | map, string | map | Utilizza la rappresentazione cartografica JSON nativa. | 
|  `smallint`  | integer, string | integer | La stringa deve essere un numero intero valido a 16 bit. | 
|  `set`  | list, string | list | Utilizza la rappresentazione nativa dell'elenco JSON. | 
|  `text`  | string | string | Utilizza l'escape dei caratteri JSON. `\u` | 
|  `time`  | string | string | Ora del giorno nel formato`HH-MM-SS[.fffffffff]`. | 
|  `timestamp`  | integer, string | string | Un Timestamp. Le costanti di stringa consentono di memorizzare i timestamp come date. Vengono restituiti timbri datari con formato. `YYYY-MM-DD HH:MM:SS.SSS` | 
|  `timeuuid`  | string | string | UUID di tipo 1. Vedi [constants](#cql.elements.constants) per il formato UUID. | 
|  `tinyint`  | integer, string | integer | La stringa deve essere un numero intero valido a 8 bit. | 
|  `tuple`  | list, string | list | Utilizza la rappresentazione nativa dell'elenco JSON. | 
|  `UDT`  | map, string | map | Utilizza la rappresentazione cartografica JSON nativa con i nomi dei campi come chiavi. | 
|  `uuid`  | string | string | Vedi [constants](#cql.elements.constants) per il formato UUID. | 
|  `varchar`  | string | string | Utilizza l'escape dei caratteri JSON. `\u` | 
|  `varint`  | integer, string | integer | Lunghezza variabile; potrebbe superare numeri interi a 32 o 64 bit nel decoder lato client. | 

# Istruzioni DDL (linguaggio di definizione dei dati) in Amazon Keyspaces
<a name="cql.ddl"></a>

Il *linguaggio di definizione dei dati* (DDL) è l'insieme di istruzioni Cassandra Query Language (CQL) che usi per gestire le strutture di dati in Amazon Keyspaces (per Apache Cassandra), come keyspace e tabelle. Utilizzi DDL per creare queste strutture di dati, modificarle dopo la creazione e rimuoverle quando non sono più in uso. Amazon Keyspaces esegue operazioni DDL in modo asincrono. Per ulteriori informazioni su come confermare il completamento di un'operazione asincrona, consulta. [Creazione ed eliminazione asincrone di spazi chiave e tabelle](functional-differences.md#functional-differences.table-keyspace-management)

 Sono supportate le seguenti istruzioni DDL: 
+  [CREA KEYSPACE](cql.ddl.keyspace.md#cql.ddl.keyspace.create) 
+  [MODIFICA KEYSPACE](cql.ddl.keyspace.md#cql.ddl.keyspace.alter) 
+  [ELIMINA KEYSPACE](cql.ddl.keyspace.md#cql.ddl.keyspace.drop) 
+  [USA](cql.ddl.keyspace.md#cql.ddl.keyspace.use) 
+  [CREA TABELLA](cql.ddl.table.md#cql.ddl.table.create) 
+  [ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter) 
+  [RIPRISTINA TABELLA](cql.ddl.table.md#cql.ddl.table.restore) 
+  [DROP TABLE](cql.ddl.table.md#cql.ddl.table.drop) 
+  [CREA TIPO](cql.ddl.type.md#cql.ddl.type.create) 
+  [TIPO DI GOCCIA](cql.ddl.type.md#cql.ddl.type.drop) 

**Topics**
+ [Keyspaces](cql.ddl.keyspace.md)
+ [Tabelle](cql.ddl.table.md)
+ [Tipi definiti dall'utente () UDTs](cql.ddl.type.md)

# Keyspaces
<a name="cql.ddl.keyspace"></a>

Un *keyspace* raggruppa tabelle correlate rilevanti per una o più applicazioni. In termini di sistema di gestione di database relazionali (RDBMS), gli spazi chiave sono più o meno simili a database, tablespace o costrutti simili.

**Nota**  
In Apache Cassandra, i keyspace determinano il modo in cui i dati vengono replicati tra più nodi di storage. Tuttavia, Amazon Keyspaces è un servizio completamente gestito: i dettagli del relativo livello di storage vengono gestiti per tuo conto. Per questo motivo, gli spazi chiave in Amazon Keyspaces sono solo costrutti logici e non sono correlati allo storage fisico sottostante.

Per informazioni sui limiti e i vincoli di quota per gli spazi chiave di Amazon Keyspaces, consulta. [Quote per Amazon Keyspaces (per Apache Cassandra)](quotas.md)

**Topics**
+ [CREA KEYSPACE](#cql.ddl.keyspace.create)
+ [ALTERA LO SPAZIO DEI TASTI](#cql.ddl.keyspace.alter)
+ [RILASCIA LO SPAZIO CHIAVE](#cql.ddl.keyspace.drop)
+ [USE](#cql.ddl.keyspace.use)

## CREA KEYSPACE
<a name="cql.ddl.keyspace.create"></a>

Usa l'`CREATE KEYSPACE`istruzione per creare un nuovo keyspace.

**Sintassi**

```
create_keyspace_statement ::= 
    CREATE KEYSPACE [ IF NOT EXISTS ] keyspace_name
    WITH options
```

Dove:
+ `keyspace_name`è il nome dello spazio chiave da creare.
+ *le opzioni* sono una o più delle seguenti:
  + `REPLICATION`— Una mappa che indica la strategia di replica per il keyspace:
    + `SingleRegionStrategy`— Per uno spazio chiave a regione singola. (Obbligatorio)
    + `NetworkTopologyStrategy`— Specificarne almeno due. Regioni AWS Il fattore di replica per ogni regione è tre. (Facoltativo)
  + `DURABLE_WRITES`— Le scritture su Amazon Keyspaces sono sempre durevoli, quindi questa opzione non è richiesta. Tuttavia, se specificato, il valore deve essere`true`.
  + `TAGS`— Un elenco di tag di coppia chiave-valore da allegare alla risorsa al momento della creazione. (Facoltativo)

**Esempio**

Create uno spazio chiave come segue.

```
CREATE KEYSPACE my_keyspace
    WITH REPLICATION = {'class': 'SingleRegionStrategy'} and TAGS ={'key1':'val1', 'key2':'val2'} ;
```

Per creare uno spazio chiave multiregionale, specificatene `NetworkTopologyStrategy` e includetene almeno due. Regioni AWS Il fattore di replica per ogni regione è tre.

```
CREATE KEYSPACE my_keyspace
    WITH REPLICATION = {'class':'NetworkTopologyStrategy', 'us-east-1':'3', 'ap-southeast-1':'3','eu-west-1':'3'};
```

## ALTERA LO SPAZIO DEI TASTI
<a name="cql.ddl.keyspace.alter"></a>

*È possibile utilizzare l'`ALTER KEYSPACE WITH`istruzione per le seguenti opzioni*
+ `REPLICATION`— Utilizzate questa opzione per aggiungere una nuova Regione AWS replica a un keyspace. È possibile aggiungere una nuova regione a una regione singola o a uno spazio chiave multiregione. 
+ `TAGS`— Utilizzate questa opzione per aggiungere o rimuovere tag da uno spazio chiave.

**Sintassi**

```
alter_keyspace_statement ::= 
    ALTER KEYSPACE keyspace_name
    WITH options
```

Dove:
+ `keyspace_name`è il nome dello spazio chiave da modificare.
+ *le opzioni* sono una delle seguenti:
  + `ADD | DROP TAGS`— Un elenco di tag di coppia chiave-valore da aggiungere o rimuovere dallo spazio delle chiavi. 
  + `REPLICATION`— Una mappa che indica la strategia di replica per il keyspace; 
    + `class`— `NetworkTopologyStrategy` definisce lo spazio chiave come uno spazio chiave multiregionale.
    + `region`— Specificarne uno aggiuntivo Regione AWS per questo keyspace. Il fattore di replica per ogni regione è tre.
    + `CLIENT_SIDE_TIMESTAMPS`— L'impostazione predefinita è`DISABLED`. È possibile modificare lo stato solo in`ENABLED`.

**Esempi**

Modificate un keyspace come mostrato nell'esempio seguente per aggiungere tag.

```
ALTER KEYSPACE my_keyspace ADD TAGS {'key1':'val1', 'key2':'val2'};
```

Per aggiungere una terza regione a uno spazio chiave multiregionale, è possibile utilizzare la seguente istruzione.

```
ALTER KEYSPACE my_keyspace
WITH REPLICATION = {
    'class': 'NetworkTopologyStrategy',
    'us-east-1': '3',
    'us-west-2': '3',
    'us-west-1': '3'
} AND CLIENT_SIDE_TIMESTAMPS = {'status': 'ENABLED'};
```

## RILASCIA LO SPAZIO CHIAVE
<a name="cql.ddl.keyspace.drop"></a>

Utilizzate l'`DROP KEYSPACE`istruzione per rimuovere uno spazio chiave, inclusi tutti i suoi contenuti, ad esempio le tabelle.

**Sintassi**

```
drop_keyspace_statement ::= 
    DROP KEYSPACE [ IF EXISTS ] keyspace_name
```

Dove:
+ *keyspace\$1name è il nome* dello spazio chiave da eliminare.

**Esempio**

```
DROP KEYSPACE my_keyspace;
```

## USE
<a name="cql.ddl.keyspace.use"></a>

Utilizzate l'`USE`istruzione per definire lo spazio chiave corrente. Ciò consente di fare riferimento a oggetti associati a uno spazio chiave specifico, ad esempio tabelle e tipi, senza utilizzare il nome completo che include il prefisso keyspace. 

**Sintassi**

```
use_statement ::= 
    USE keyspace_name
```

Dove:
+ *keyspace\$1name è il nome* del keyspace da utilizzare.

**Esempio**

```
USE my_keyspace;
```

# Tabelle
<a name="cql.ddl.table"></a>

Le *tabelle* sono le strutture di dati principali in Amazon Keyspaces. I dati in una tabella sono organizzati in righe e colonne. Un sottoinsieme di queste colonne viene utilizzato per determinare il partizionamento (e in ultima analisi il posizionamento dei dati) mediante la specificazione di una chiave di partizione.

Un altro set di colonne può essere definito in colonne di clustering, il che significa che possono partecipare come predicati all'esecuzione delle query. 

Per impostazione predefinita, vengono create nuove tabelle con capacità di throughput *su richiesta*. È possibile modificare la modalità di capacità per tabelle nuove ed esistenti. Per ulteriori informazioni sulle modalità di throughput read/write della capacità, vedere[Configura le modalità di read/write capacità in Amazon Keyspaces](ReadWriteCapacityMode.md). 

Per le tabelle in modalità provisioning, è possibile configurare in modo facoltativo. `AUTOSCALING_SETTINGS` Per ulteriori informazioni sulla scalabilità automatica di Amazon Keyspaces e sulle opzioni disponibili, consulta. [Configura il ridimensionamento automatico su una tabella esistente](autoscaling.configureTable.md)

Per informazioni sui limiti e i vincoli di quota per le tabelle Amazon Keyspaces, consulta. [Quote per Amazon Keyspaces (per Apache Cassandra)](quotas.md)

**Topics**
+ [CREATE TABLE](#cql.ddl.table.create)
+ [ALTER TABLE](#cql.ddl.table.alter)
+ [RIPRISTINARE LA TABELLA](#cql.ddl.table.restore)
+ [DROP TABLE](#cql.ddl.table.drop)

## CREATE TABLE
<a name="cql.ddl.table.create"></a>

Utilizzate l'`CREATE TABLE`istruzione per creare una nuova tabella.

 **Sintassi**

```
create_table_statement ::=  CREATE TABLE [ IF NOT EXISTS ] table_name
    '('
        column_definition 
        ( ',' column_definition )*
        [ ',' PRIMARY KEY '(' primary_key ')' ]
    ')' [ WITH table_options ]

column_definition      ::=  column_name cql_type [ FROZEN ][ STATIC ][ PRIMARY KEY]

primary_key            ::=  partition_key [ ',' clustering_columns ]

partition_key          ::=  column_name
                              | '(' column_name ( ',' column_name )* ')'

clustering_columns     ::=  column_name ( ',' column_name )*

table_options          ::=  [table_options]
                              | CLUSTERING ORDER BY '(' clustering_order ')' [ AND table_options ]
                              | cdc
                              | CUSTOM_PROPERTIES
                              | AUTOSCALING_SETTINGS
                              | default_time_to_live
                              | TAGS

clustering_order       ::=  column_name (ASC | DESC) ( ',' column_name (ASC | DESC) )*
```

Dove:
+ `table_name`è il nome della tabella da creare. Il nome completo include il prefisso keyspace. In alternativa, è possibile impostare lo spazio chiave corrente con l'`USE`istruzione keyspace.
+ `column_definition`è composto da quanto segue:
  +  *`column_name`*— Il nome della colonna.
  + `cql_type`— Un tipo di dati Amazon Keyspaces (vedi[Tipi di dati](cql.elements.md#cql.data-types)).
  + `FROZEN`— Indica questa colonna definita dall'utente o di tipo `collection` (ad esempio, `LIST``SET`, o`MAP`) come congelata. Una raccolta *congelata* viene serializzata in un unico valore immutabile e trattata come una. `BLOB` Per ulteriori informazioni, consulta [Tipi di raccolta](cql.elements.md#cql.data-types.collection).
  + `STATIC`— Indica questa colonna come statica. Le colonne statiche memorizzano i valori condivisi da tutte le righe della stessa partizione.
  + `PRIMARY KEY`— Indica questa colonna come chiave primaria della tabella.
+ `primary_key`è composto da quanto segue:
  + `partition_key`
  + `clustering_columns`
+ `partition_key`:
  + La chiave di partizione può essere una singola colonna o un valore composto da due o più colonne. La parte relativa alla chiave di partizione della chiave primaria è obbligatoria e determina in che modo Amazon Keyspaces archivia i dati. 
+ `clustering_columns`:
  + La parte opzionale della colonna di clustering della chiave primaria determina il modo in cui i dati vengono raggruppati e ordinati all'interno di ciascuna partizione. 
+ `table_options`sono costituite da quanto segue:
  + *`CLUSTERING ORDER BY`*— Il CLUSTERING ORDER predefinito su una tabella è composto dalle chiavi di raggruppamento nella direzione di ordinamento `ASC` (crescente). Specificalo per ignorare il comportamento di ordinamento predefinito. 
  +  *`cdc`*— Un valore booleano che specifica se Amazon Keyspaces crea un flusso CDC (change data capture) per la tabella. Il valore predefinito è `false`. Per specificare `view type` quando abilitare uno stream, imposta il with. `cdc_specification` `CUSTOM_PROPERTIES` 
  +  *`CUSTOM_PROPERTIES`*— Una mappa di impostazioni specifiche di Amazon Keyspaces.
    +  `capacity_mode`: specifica la modalità di capacità di velocità effettiva di lettura/scrittura per la tabella. Le opzioni sono `throughput_mode:PAY_PER_REQUEST` e `throughput_mode:PROVISIONED`. La modalità di capacità fornita richiede e come input. `read_capacity_units` `write_capacity_units` Il valore predefinito è `throughput_mode:PAY_PER_REQUEST`.
    +  `cdc_specification`: specifica il flusso `view_type` CDC. Le opzioni sono:
      + `NEW_AND_OLD_IMAGES`— entrambe le versioni della riga, prima e dopo la modifica. Questa è l’impostazione predefinita.
      + `NEW_IMAGE`— la versione della riga dopo la modifica.
      + `OLD_IMAGE`— la versione della riga prima della modifica.
      + `KEYS_ONLY`— le chiavi di partizione e di clustering della riga che è stata modificata.

      Per ulteriori informazioni sugli stream CDC, vedere. [Utilizzo di flussi di acquisizione dati di modifica (CDC) in Amazon Keyspaces](cdc.md) Per alcuni esempi di codice, consultare [Abilita uno stream CDC durante la creazione di una nuova tabella in Amazon Keyspaces](keyspaces-enable-cdc-new-table.md).
    +  `client_side_timestamps`: specifica se i timestamp lato client sono abilitati o disabilitati per la tabella. Le opzioni sono `{'status': 'enabled'}` e `{'status': 'disabled'}`. Se non è specificato, l'impostazione predefinita è. `status:disabled` Dopo aver abilitato i timestamp lato client per una tabella, questa impostazione non può essere disabilitata. 
    +  `encryption_specification`: specifica le opzioni di crittografia per la crittografia a riposo. Se non è specificato, l'impostazione predefinita è`encryption_type:AWS_OWNED_KMS_KEY`. L'opzione di crittografia la chiave gestita dal cliente richiede la AWS KMS chiave in formato Amazon Resource Name (ARN) come input::`kms_key_identifier:ARN`. `kms_key_identifier:ARN` 
    +  `point_in_time_recovery`: specifica se il point-in-time ripristino è abilitato o disabilitato per la tabella. Le opzioni sono `status:enabled` e `status:disabled`. Se non è specificato, l'impostazione predefinita è`status:disabled`.
    + `replica_updates`: specifica le impostazioni di una tabella multiarea specifiche di un. Regione AWS Per una tabella con più regioni, è possibile configurare la capacità di lettura della tabella in modo diverso per. Regione AWSÈ possibile farlo configurando i seguenti parametri. Per maggiori informazioni ed esempi, consulta [Crea una tabella multiregionale in modalità provisioning con scalabilità automatica in Amazon Keyspaces](tables-mrr-create-provisioned.md).
      + `region`— La replica Regione AWS della tabella con le seguenti impostazioni:
        + `read_capacity_units`
    +  `TTL`: abilita le impostazioni personalizzate Time to Live per la tabella. Per abilitare, usa`status:enabled`. Il valore predefinito è `status:disabled`. Dopo averlo `TTL` abilitato, non puoi disabilitarlo per la tabella.
  + `AUTOSCALING_SETTINGS`include le seguenti impostazioni opzionali per le tabelle in modalità provisioning. Per maggiori informazioni ed esempi, consulta [Crea una nuova tabella con ridimensionamento automatico](autoscaling.createTable.md).
    + `provisioned_write_capacity_autoscaling_update`:
      + `autoscaling_disabled`— Per abilitare la scalabilità automatica per la capacità di scrittura, impostare il valore su. `false` Il valore predefinito è `true`. (Facoltativo)
      + `minimum_units`— Il livello minimo di velocità di scrittura che la tabella dovrebbe essere sempre pronta a supportare. Il valore deve essere compreso tra 1 e la quota massima di throughput al secondo prevista per l'account (40.000 per impostazione predefinita).
      + `maximum_units`— Il livello massimo di velocità di scrittura che la tabella dovrebbe essere sempre pronta a supportare. Il valore deve essere compreso tra 1 e la quota massima di throughput al secondo prevista per l'account (40.000 per impostazione predefinita).
      + `scaling_policy`— Amazon Keyspaces supporta la politica di tracciamento degli obiettivi. L'obiettivo di auto scaling è la capacità di scrittura assegnata alla tabella.
        + `target_tracking_scaling_policy_configuration`— Per definire la politica di tracciamento del target, è necessario definire il valore target. Per ulteriori informazioni sul tracciamento del target e sui periodi di cooldown, consulta [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) nella *Application Auto Scaling* User Guide. 
          + `target_value`— Il tasso di utilizzo previsto della tabella. La scalabilità automatica di Amazon Keyspaces assicura che il rapporto tra capacità consumata e capacità fornita rimanga pari o vicino a questo valore. `target_value` viene definito in percentuale. Un doppio tra 20 e 90. (Obbligatorio)
          + `scale_in_cooldown`— Un periodo di recupero in secondi tra le attività di ridimensionamento che consente alla tabella di stabilizzarsi prima che inizi un'altra scala di attività. Se non viene fornito alcun valore, il valore predefinito è 0. (Facoltativo)
          + `scale_out_cooldown`— Un periodo di recupero in secondi tra le attività di ridimensionamento che consente alla tabella di stabilizzarsi prima che inizi un'altra attività di scalabilità orizzontale. Se non viene fornito alcun valore, il valore predefinito è 0. (Facoltativo)
          + `disable_scale_in`: A `boolean` che specifica se `scale-in` è disabilitato o abilitato per la tabella. Questo parametro è disabilitato per impostazione predefinita. Per attivarlo`scale-in`, imposta il `boolean` valore su`FALSE`. Ciò significa che la capacità viene automaticamente ridotta per una tabella per tuo conto. (Facoltativo) 
    + `provisioned_read_capacity_autoscaling_update`:
      + `autoscaling_disabled`— Per abilitare la scalabilità automatica per la capacità di lettura, impostare il valore su. `false` Il valore predefinito è `true`. (Facoltativo)
      + `minimum_units`— Il livello minimo di velocità effettiva che la tabella dovrebbe essere sempre pronta a supportare. Il valore deve essere compreso tra 1 e la quota massima di throughput al secondo prevista per l'account (40.000 per impostazione predefinita).
      + `maximum_units`— Il livello massimo di velocità effettiva che la tabella dovrebbe essere sempre pronta a supportare. Il valore deve essere compreso tra 1 e la quota massima di throughput al secondo prevista per l'account (40.000 per impostazione predefinita).
      + `scaling_policy`— Amazon Keyspaces supporta la politica di tracciamento degli obiettivi. L'obiettivo della scalabilità automatica è la capacità di lettura assegnata alla tabella.
        + `target_tracking_scaling_policy_configuration`— Per definire la politica di tracciamento del target, è necessario definire il valore target. Per ulteriori informazioni sul tracciamento del target e sui periodi di cooldown, consulta [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) nella *Application Auto Scaling* User Guide. 
          + `target_value`— Il tasso di utilizzo previsto della tabella. La scalabilità automatica di Amazon Keyspaces assicura che il rapporto tra capacità consumata e capacità fornita rimanga pari o vicino a questo valore. `target_value` viene definito in percentuale. Un doppio tra 20 e 90. (Obbligatorio)
          + `scale_in_cooldown`— Un periodo di recupero in secondi tra le attività di ridimensionamento che consente alla tabella di stabilizzarsi prima che inizi un'altra scala di attività. Se non viene fornito alcun valore, il valore predefinito è 0. (Facoltativo)
          + `scale_out_cooldown`— Un periodo di recupero in secondi tra le attività di ridimensionamento che consente alla tabella di stabilizzarsi prima che inizi un'altra attività di scalabilità orizzontale. Se non viene fornito alcun valore, il valore predefinito è 0. (Facoltativo)
          + `disable_scale_in`: A `boolean` che specifica se `scale-in` è disabilitato o abilitato per la tabella. Questo parametro è disabilitato per impostazione predefinita. Per attivarlo`scale-in`, imposta il `boolean` valore su`FALSE`. Ciò significa che la capacità viene automaticamente ridotta per una tabella per tuo conto. (Facoltativo) 
    + `replica_updates`: specifica le impostazioni di ridimensionamento automatico Regione AWS specifiche di una tabella multiregione. Per una tabella con più regioni, è possibile configurare la capacità di lettura della tabella in modo diverso per. Regione AWSÈ possibile farlo configurando i seguenti parametri. Per maggiori informazioni ed esempi, consulta [Aggiorna la capacità fornita e le impostazioni di ridimensionamento automatico per una tabella multiregionale in Amazon Keyspaces](tables-mrr-autoscaling.md).
      + `region`— La replica Regione AWS della tabella con le seguenti impostazioni:
        + `provisioned_read_capacity_autoscaling_update`
          + `autoscaling_disabled`— Per abilitare il ridimensionamento automatico della capacità di lettura della tabella, impostate il valore su. `false` Il valore predefinito è `true`. (Facoltativo) 
**Nota**  
Il ridimensionamento automatico per una tabella con più regioni deve essere abilitato o disabilitato per tutte le repliche della tabella.
          + `minimum_units`— Il livello minimo di velocità di lettura che la tabella dovrebbe essere sempre pronta a supportare. Il valore deve essere compreso tra 1 e la quota massima di throughput al secondo prevista per l'account (40.000 per impostazione predefinita).
          + `maximum_units`— Il livello massimo di velocità di lettura che la tabella dovrebbe essere sempre pronta a supportare. Il valore deve essere compreso tra 1 e la quota massima di throughput al secondo prevista per l'account (40.000 per impostazione predefinita).
          + `scaling_policy`— Amazon Keyspaces supporta la politica di tracciamento degli obiettivi. L'obiettivo della scalabilità automatica è la capacità di lettura assegnata alla tabella.
            + `target_tracking_scaling_policy_configuration`— Per definire la politica di tracciamento del target, è necessario definire il valore target. Per ulteriori informazioni sul tracciamento del target e sui periodi di cooldown, consulta [Target Tracking Scaling Policies](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) nella *Application Auto Scaling* User Guide. 
              + `target_value`— Il tasso di utilizzo previsto della tabella. La scalabilità automatica di Amazon Keyspaces assicura che il rapporto tra la capacità di lettura consumata e la capacità di lettura assegnata rimanga pari o vicino a questo valore. `target_value` viene definito in percentuale. Un doppio tra 20 e 90. (Obbligatorio)
              + `scale_in_cooldown`— Un periodo di recupero in secondi tra le attività di ridimensionamento che consente alla tabella di stabilizzarsi prima che inizi un'altra scala di attività. Se non viene fornito alcun valore, il valore predefinito è 0. (Facoltativo)
              + `scale_out_cooldown`— Un periodo di recupero in secondi tra le attività di ridimensionamento che consente alla tabella di stabilizzarsi prima che inizi un'altra attività di scalabilità orizzontale. Se non viene fornito alcun valore, il valore predefinito è 0. (Facoltativo)
              + `disable_scale_in`: A `boolean` che specifica se `scale-in` è disabilitato o abilitato per la tabella. Questo parametro è disabilitato per impostazione predefinita. Per attivarlo`scale-in`, imposta il `boolean` valore su`FALSE`. Ciò significa che la capacità di lettura viene automaticamente ridotta per una tabella per conto dell'utente. (Facoltativo) 
  + `default_time_to_live`— L'impostazione predefinita del Time to Live in secondi per il tavolo.
  + `TAGS`— Un elenco di tag di coppia chiave-valore da allegare alla risorsa al momento della creazione. 
  + `clustering_order`è composto da quanto segue:
    +  *`column_name`*— Il nome della colonna. 
    +  *`ASC | DESC`*— Imposta il modificatore di ordine ascendente (`ASC`) o discendente (`DESC`). Se non è specificato, l'ordine predefinito è ASC. 

**Esempio**

```
CREATE TABLE IF NOT EXISTS my_keyspace.my_table (
                                            id text,
                                            name text,
                                            region text,
                                            division text,
                                            project text,
                                            role text,
                                            pay_scale int,
                                            vacation_hrs float,
                                            manager_id text,
                                            PRIMARY KEY (id,division))
                                            WITH CUSTOM_PROPERTIES={
                                                'capacity_mode':{
                                                        'throughput_mode': 'PROVISIONED', 'read_capacity_units': 10, 'write_capacity_units': 20
                                                    },
                                                'point_in_time_recovery':{'status': 'enabled'},
                                                'encryption_specification':{
                                                        'encryption_type': 'CUSTOMER_MANAGED_KMS_KEY', 
                                                        'kms_key_identifier':'arn:aws:kms:eu-west-1:5555555555555:key/11111111-1111-111-1111-111111111111'
                                                    }
                                            }
                                            AND CLUSTERING ORDER BY (division ASC) 
                                            AND TAGS={'key1':'val1', 'key2':'val2'}
                                            AND default_time_to_live = 3024000;
```

In una tabella che utilizza colonne di clustering, le colonne non raggruppate possono essere dichiarate statiche nella definizione della tabella. Per ulteriori informazioni sulle colonne statiche, vedere. [Stima del consumo di capacità per le colonne statiche in Amazon Keyspaces](static-columns.md)

**Esempio**

```
CREATE TABLE my_keyspace.my_table (
                                            id int,
                                            name text,
                                            region text,
                                            division text,
                                            project text STATIC,
                                            PRIMARY KEY (id,division));
```

È possibile creare una tabella con una colonna che utilizza un tipo definito dall'utente (UDT). La prima istruzione negli esempi crea un tipo, la seconda istruzione crea una tabella con una colonna che utilizza il tipo.

**Esempio**

```
CREATE TYPE my_keyspace."udt""N@ME" (my_field int);
CREATE TABLE my_keyspace.my_table (my_col1 int pri key, my_col2 "udt""N@ME");
```

## ALTER TABLE
<a name="cql.ddl.table.alter"></a>

Utilizzate l'`ALTER TABLE`istruzione per aggiungere nuove colonne, aggiungere tag o modificare le proprietà personalizzate della tabella.

**Sintassi**

```
alter_table_statement ::=  ALTER TABLE table_name    
 
        [ ADD ( column_definition | column_definition_list)  ] 
        [[ADD | DROP] TAGS {'key1':'val1', 'key2':'val2'}]            
        [ WITH table_options [ , ... ] ] ;
        
column_definition      ::=  column_name cql_type
```

Dove:
+ `table_name`è il nome della tabella da modificare.
+ `column_definition`è il nome della colonna e del tipo di dati da aggiungere.
+ `column_definition_list`è un elenco di colonne separate da virgole inserite tra parentesi.
+ `table_options`sono costituiti da quanto segue:
  + `AUTOSCALING_SETTINGS`include le impostazioni di ridimensionamento automatico opzionali per le tabelle predisposte. Per la sintassi e le descrizioni dettagliate, vedere. [CREATE TABLE](#cql.ddl.table.create) Per alcuni esempi, consulta [Configura il ridimensionamento automatico su una tabella esistente](autoscaling.configureTable.md).
  +  *`cdc`*— Un valore booleano che specifica se Amazon Keyspaces crea un flusso CDC (change data capture) per la tabella. Il valore predefinito è `false`. Per specificare `view type` quando abilitare uno stream, imposta il with. `cdc_specification` `CUSTOM_PROPERTIES` 
  +  *`CUSTOM_PROPERTIES`*— Una mappa di impostazioni specifiche per Amazon Keyspaces.
    +  `capacity_mode`: specifica la modalità di capacità di velocità effettiva di lettura/scrittura per la tabella. Le opzioni sono `throughput_mode:PAY_PER_REQUEST` e `throughput_mode:PROVISIONED`. La modalità di capacità fornita richiede e come input. `read_capacity_units` `write_capacity_units` Il valore predefinito è `throughput_mode:PAY_PER_REQUEST`.
    +  `cdc_specification`: specifica il flusso `view_type` CDC. Le opzioni sono:
      + `NEW_AND_OLD_IMAGES`— entrambe le versioni della riga, prima e dopo la modifica. Questa è l’impostazione predefinita.
      + `NEW_IMAGE`— la versione della riga dopo la modifica.
      + `OLD_IMAGE`— la versione della riga prima della modifica.
      + `KEYS_ONLY`— le chiavi di partizione e di clustering della riga che è stata modificata.

      Per ulteriori informazioni sugli stream CDC, vedere. [Utilizzo di flussi di acquisizione dati di modifica (CDC) in Amazon Keyspaces](cdc.md) Per alcuni esempi di codice, consultare [Abilita uno stream CDC per una tabella esistente in Amazon Keyspaces](keyspaces-enable-cdc-alter-table.md).
    +  `client_side_timestamps`: specifica se i timestamp lato client sono abilitati o disabilitati per la tabella. Le opzioni sono `{'status': 'enabled'}` e `{'status': 'disabled'}`. Se non è specificato, l'impostazione predefinita è. `status:disabled` Dopo aver abilitato i timestamp lato client per una tabella, questa impostazione non può essere disabilitata. 
    +  `encryption_specification`: specifica l'opzione di crittografia per la crittografia a riposo. Le opzioni sono `encryption_type:AWS_OWNED_KMS_KEY` e `encryption_type:CUSTOMER_MANAGED_KMS_KEY`. L'opzione di crittografia la chiave gestita dal cliente richiede la AWS KMS chiave in formato Amazon Resource Name (ARN) come input:. `kms_key_identifier:ARN` 
    +  `point_in_time_recovery`: specifica se il point-in-time ripristino è abilitato o disabilitato per la tabella. Le opzioni sono `status:enabled` e `status:disabled`. Il valore predefinito è `status:disabled`.
    + `replica_updates`: specifica le impostazioni Regione AWS specifiche di una tabella con più regioni. Per una tabella con più regioni, è possibile configurare la capacità di lettura della tabella in modo diverso per. Regione AWSÈ possibile farlo configurando i seguenti parametri. Per maggiori informazioni ed esempi, consulta [Aggiorna la capacità fornita e le impostazioni di ridimensionamento automatico per una tabella multiregionale in Amazon Keyspaces](tables-mrr-autoscaling.md).
      + `region`— La replica Regione AWS della tabella con le seguenti impostazioni:
        + `read_capacity_units` 
    +  `ttl`: abilita le impostazioni personalizzate Time to Live per la tabella. Per abilitare, usa`status:enabled`. Il valore predefinito è `status:disabled`. Dopo averlo `ttl` abilitato, non puoi disabilitarlo per la tabella.
+ `default_time_to_live`: l'impostazione predefinita del Time to Live in secondi per la tabella.
+ `TAGS`è un elenco di tag di coppia chiave-valore da allegare alla risorsa.

**Nota**  
Con ALTER TABLE, puoi modificare solo una singola proprietà personalizzata. Non è possibile combinare più di un comando ALTER TABLE nella stessa istruzione.

**Esempi**

L'istruzione seguente mostra come aggiungere una colonna a una tabella esistente.

```
ALTER TABLE mykeyspace.mytable ADD (ID int);
```

Questa istruzione mostra come aggiungere due colonne di raccolta a una tabella esistente: 
+ Una colonna di raccolta congelata `col_frozen_list` che contiene una raccolta congelata annidata
+ Una colonna di raccolta non congelata `col_map` che contiene una raccolta congelata annidata

```
ALTER TABLE my_Table ADD(col_frozen_list FROZEN<LIST<FROZEN<SET<TEXT>>>>, col_map MAP<INT, FROZEN<SET<INT>>>);
```

L'esempio seguente mostra come aggiungere una colonna che utilizza un tipo definito dall'utente (UDT) a una tabella.

```
ALTER TABLE my_keyspace.my_table ADD (my_column, my_udt;);
```

Per modificare la modalità di capacità di una tabella e specificare le unità di capacità di lettura e scrittura, è possibile utilizzare la seguente istruzione.

```
ALTER TABLE mykeyspace.mytable WITH CUSTOM_PROPERTIES={'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 10, 'write_capacity_units': 20}};
```

L'istruzione seguente specifica una chiave KMS gestita dal cliente per la tabella.

```
ALTER TABLE mykeyspace.mytable WITH CUSTOM_PROPERTIES={     
              'encryption_specification':{ 
                      'encryption_type': 'CUSTOMER_MANAGED_KMS_KEY', 
                      'kms_key_identifier':'arn:aws:kms:eu-west-1:5555555555555:key/11111111-1111-111-1111-111111111111'     
                  } 
         };
```

Per abilitare point-in-time il ripristino di una tabella, è possibile utilizzare la seguente istruzione.

```
ALTER TABLE mykeyspace.mytable WITH CUSTOM_PROPERTIES={'point_in_time_recovery': {'status': 'enabled'}};
```

Per impostare un valore Time to Live predefinito in secondi per una tabella, è possibile utilizzare la seguente istruzione.

```
ALTER TABLE my_table WITH default_time_to_live = 2592000;
```

Questa istruzione abilita le impostazioni Time to Live personalizzate per una tabella.

```
ALTER TABLE mytable WITH CUSTOM_PROPERTIES={'ttl':{'status': 'enabled'}};
```

## RIPRISTINARE LA TABELLA
<a name="cql.ddl.table.restore"></a>

Utilizzare l'`RESTORE TABLE`istruzione per ripristinare una tabella in un determinato momento. Questa istruzione richiede che point-in-time il ripristino sia abilitato su una tabella. Per ulteriori informazioni, consulta [Backup e ripristino dei dati con point-in-time ripristino per Amazon Keyspaces](PointInTimeRecovery.md).

**Sintassi**

```
restore_table_statement ::=  
    RESTORE TABLE restored_table_name FROM TABLE source_table_name 
                    [ WITH table_options [ , ... ] ];
```

Dove:
+ `restored_table_name`è il nome della tabella ripristinata.
+ `source_table_name`è il nome della tabella di origine.
+ `table_options`è composto da quanto segue:
  + `restore_timestamp`è l'ora del punto di ripristino in formato ISO 8601. Se non è specificato, viene utilizzato il timestamp corrente.
  +  *`CUSTOM_PROPERTIES`*— Una mappa di impostazioni specifiche per Amazon Keyspaces.
    +  `capacity_mode`: specifica la modalità di capacità di velocità effettiva di lettura/scrittura per la tabella. Le opzioni sono `throughput_mode:PAY_PER_REQUEST` e `throughput_mode:PROVISIONED`. La modalità di capacità fornita richiede e come input. `read_capacity_units` `write_capacity_units` L'impostazione predefinita è l'impostazione corrente della tabella di origine.
    +  `encryption_specification`: specifica l'opzione di crittografia per la crittografia a riposo. Le opzioni sono `encryption_type:AWS_OWNED_KMS_KEY` e `encryption_type:CUSTOMER_MANAGED_KMS_KEY`. L'opzione di crittografia la chiave gestita dal cliente richiede la AWS KMS chiave in formato Amazon Resource Name (ARN) come input:. `kms_key_identifier:ARN` Per ripristinare una tabella crittografata con una chiave gestita dal cliente su una tabella crittografata con un Chiave di proprietà di AWS, Amazon Keyspaces richiede l'accesso alla AWS KMS chiave della tabella di origine.
    +  `point_in_time_recovery`: specifica se il point-in-time ripristino è abilitato o disabilitato per la tabella. Le opzioni sono `status:enabled` e `status:disabled`. A differenza di quando si creano nuove tabelle, lo stato predefinito per le tabelle ripristinate è `status:enabled` dovuto al fatto che l'impostazione viene ereditata dalla tabella di origine. Per disabilitare PITR per le tabelle ripristinate, è necessario `status:disabled` impostarlo in modo esplicito.
    + `replica_updates`: specifica le impostazioni Regione AWS specifiche di una tabella multiregionale. Per una tabella con più regioni, è possibile configurare la capacità di lettura della tabella in modo diverso per. Regione AWSÈ possibile farlo configurando i seguenti parametri. 
      + `region`— La replica Regione AWS della tabella con le seguenti impostazioni:
        + `read_capacity_units` 
  + `AUTOSCALING_SETTINGS`include le impostazioni di ridimensionamento automatico opzionali per le tabelle predisposte. Per una sintassi e una descrizione dettagliate, vedere. [CREATE TABLE](#cql.ddl.table.create)
  + `TAGS`è un elenco di tag di coppia chiave-valore da allegare alla risorsa.

**Nota**  
Le tabelle eliminate possono essere ripristinate solo al momento dell'eliminazione.

**Esempio**

```
RESTORE TABLE mykeyspace.mytable_restored from table mykeyspace.my_table 
WITH restore_timestamp = '2020-06-30T04:05:00+0000'
AND custom_properties = {'point_in_time_recovery':{'status':'disabled'}, 'capacity_mode':{'throughput_mode': 'PROVISIONED', 'read_capacity_units': 10, 'write_capacity_units': 20}}
AND TAGS={'key1':'val1', 'key2':'val2'};
```

## DROP TABLE
<a name="cql.ddl.table.drop"></a>

Utilizzate l'`DROP TABLE`istruzione per rimuovere una tabella dallo spazio delle chiavi.

**Sintassi**

```
drop_table_statement ::=  
    DROP TABLE [ IF EXISTS ] table_name
```

Dove:
+ `IF EXISTS``DROP TABLE`impedisce di fallire se la tabella non esiste. (Facoltativo)
+ `table_name`è il nome della tabella da eliminare.

**Esempio**

```
DROP TABLE my_keyspace.my_table;
```

# Tipi definiti dall'utente () UDTs
<a name="cql.ddl.type"></a>

*UDT*: un raggruppamento di campi e tipi di dati che puoi utilizzare per definire una singola colonna in Amazon Keyspaces. I tipi di dati validi UDTs sono tutti i tipi di dati Cassandra supportati, comprese le raccolte e altri UDTs che hai già creato nello stesso keyspace. Per ulteriori informazioni sui tipi di dati Cassandra supportati, consulta. [Supporto per i tipi di dati Cassandra](cassandra-apis.md#cassandra-data-type)

```
user_defined_type::= udt_name
udt_name::= [ keyspace_name '.' ] identifier
```

**Topics**
+ [CREATE TYPE](#cql.ddl.type.create)
+ [DROP TYPE](#cql.ddl.type.drop)

## CREATE TYPE
<a name="cql.ddl.type.create"></a>

Utilizzate l'`CREATE TYPE`istruzione per creare un nuovo tipo.

 **Sintassi**

```
create_type_statement ::=  CREATE TYPE [ IF NOT EXISTS ] udt_name
    '('field_definition ( ',' field_definition)* ')'
            field_definition::= identifier cql_type
```

Dove:
+ `IF NOT EXISTS``CREATE TYPE`impedisce di fallire se il tipo esiste già. (Facoltativo)
+ `udt_name`è il nome completo dell'UDT in formato type, ad esempio. `my_keyspace.my_type` Se si definisce lo spazio chiave corrente con l'`USE`istruzione, non è necessario specificare il nome dello spazio chiave.
+ `field_definition`è costituito da un nome e da un tipo.

La tabella seguente mostra esempi di nomi UDT consentiti. La prima colonna mostra come inserire il nome quando si crea il tipo, la seconda colonna mostra come Amazon Keyspaces formatta il nome internamente. Amazon Keyspaces prevede il nome formattato per operazioni come. `GetType`


| Nome inserito | Nome formattato | Nota | 
| --- | --- | --- | 
|  MY\$1UDT  | my\$1udt | Senza virgolette, Amazon Keyspaces converte tutti i caratteri maiuscoli in minuscoli. | 
|  "MY\$1UDT"  | MY\$1UDT | Con le virgolette doppie, Amazon Keyspaces rispetta i caratteri maiuscoli e rimuove le virgolette dal nome formattato. | 
|  "1234"  | 1234 | Con le virgolette doppie, il nome può iniziare con un numero e Amazon Keyspaces rimuove le virgolette dal nome formattato. | 
|  "Special\$1Ch@r@cters<>\$1\$1"  | Special\$1Ch@r@cters<>\$1\$1 | Con le virgolette doppie, il nome può contenere caratteri speciali e Amazon Keyspaces rimuove le virgolette dal nome formattato. | 
|  "nested""""""quotes"  | nested"""quotes | Amazon Keyspaces rimuove le virgolette doppie esterne e le virgolette di escape dal nome formattato. | 

**Esempi**

```
CREATE TYPE my_keyspace.phone (
    country_code int,
    number text
);
```

Puoi nidificare UDTs se l'UDT annidato è bloccato. Per ulteriori informazioni sui valori predefiniti e sulle quote per i tipi, consulta. [Quote e valori predefiniti di Amazon Keyspaces UDT](quotas.md#udt-table)

```
CREATE TYPE my_keyspace.user (
    first_name text,
    last_name text,
    phones FROZEN<phone>
);
```

Per altri esempi di codice che mostrano come creare UDTs, consulta[Tipi definiti dall'utente (UDTs) in Amazon Keyspaces](udts.md).

## DROP TYPE
<a name="cql.ddl.type.drop"></a>

Utilizzate l'`DROP TYPE`istruzione per eliminare un UDT. È possibile eliminare solo un tipo che non è utilizzato da un altro tipo o tabella.

 **Sintassi**

```
drop_type_statement ::=  DROP TYPE [ IF EXISTS ] udt_name
```

Dove:
+ `IF EXISTS``DROP TYPE`impedisce di fallire se il tipo non esiste. (Facoltativo)
+ `udt_name`è il nome completo dell'UDT in formato type, ad esempio. `my_keyspace.my_type` Se si definisce lo spazio chiave corrente con l'`USE`istruzione, non è necessario specificare il nome dello spazio chiave.

**Esempio**

```
DROP TYPE udt_name;
```

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

# Funzioni integrate in Amazon Keyspaces
<a name="cql.functions"></a>

Amazon Keyspaces (per Apache Cassandra) supporta una varietà di funzioni integrate che puoi usare nelle istruzioni Cassandra Query Language (CQL).

**Topics**
+ [Funzioni scalari](#cql.functions.scalar)

## Funzioni scalari
<a name="cql.functions.scalar"></a>

Una *funzione scalare* esegue un calcolo su un singolo valore e restituisce il risultato come valore singolo. Amazon Keyspaces supporta le seguenti funzioni scalari.


****  

| Funzione | Description | 
| --- | --- | 
|  `blobAsType`  | Restituisce un valore del tipo di dati specificato. | 
|  `cast`  | Converte un tipo di dati nativo in un altro tipo di dati nativo. | 
|  `currentDate`  | Restituisce la data corrente date/time . | 
|  `currentTime`  | Restituisce la corrente date/time come ora. | 
|  `currentTimestamp`  | Restituisce la corrente date/time come timestamp. | 
|  `currentTimeUUID`  | Restituisce la corrente date/time come a. timeuuid | 
|  `fromJson`  | Converte la stringa JSON nel tipo di dati della colonna selezionata.  | 
|  `maxTimeuuid`  | Restituisce il valore più grande possibile timeuuid per il timestamp o la stringa di data.  | 
|  `minTimeuuid`  | Restituisce il valore più piccolo possibile timeuuid per il timestamp o la stringa di data.  | 
|  `now`  | Restituisce un nuovo codice univoco. timeuuid  | 
|  `toDate`  | Converte un timestamp timeuuid o un timestamp in un tipo di data. | 
|  `toJson`  | Restituisce il valore della colonna selezionata in formato JSON.  | 
|  `token`  | Restituisce il valore hash della chiave di partizione.  | 
|  `toTimestamp`  | Converte una timeuuid o una data in un timestamp. | 
|  `TTL`  | Restituisce il tempo di scadenza in secondi per una colonna. | 
|  `typeAsBlob`  | Converte il tipo di dati specificato in unblob. | 
|  `toUnixTimestamp`  | Converte un timestamp timeuuid o un timestamp in un. bigInt | 
|  `uuid`  | Restituisce un UUID casuale della versione 4.  | 
|  `writetime`  | Restituisce il timestamp del valore della colonna specificata. | 
|  `dateOf`  | (Obsoleto) Estrae il timestamp di a e restituisce il valore come timeuuid data. | 
|  `unixTimestampOf`  | (Obsoleto) Estrae il timestamp di a e restituisce il valore come timestamp intero non elaborato a 64 timeuuid bit.  | 