

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Référence du langage CQL pour Amazon Keyspaces (pour Apache Cassandra)
<a name="cql"></a>

Après vous être connecté à un point de terminaison Amazon Keyspaces, vous utilisez le langage de requête Cassandra (CQL) pour travailler avec votre base de données. CQL est similaire à de nombreux égards au langage SQL (Structured Query Language).
+ **Éléments CQL** — Cette section couvre les éléments fondamentaux du CQL pris en charge par Amazon Keyspaces, notamment les identifiants, les constantes, les termes et les types de données. Il explique des concepts tels que les types de chaînes, les types numériques, les types de collection, etc. 
+ **Langage de définition des données (DDL)** : les instructions DDL sont utilisées pour gérer les structures de données telles que les espaces clés et les tables dans Amazon Keyspaces. Cette section couvre les instructions relatives à la création, à la modification et à la suppression d'espaces clés et de tables, ainsi qu'à la restauration de tables à partir d'une point-in-time sauvegarde. 
+ **Langage de manipulation des données (DML)** : les instructions DML sont utilisées pour gérer les données contenues dans les tables. Cette section couvre les instructions relatives à la sélection, à l'insertion, à la mise à jour et à la suppression de données. Il explique également les fonctionnalités de requête avancées telles que l'utilisation de l'`IN`opérateur, le classement des résultats et la pagination. 
+ **Fonctions intégrées** — Amazon Keyspaces prend en charge une variété de fonctions scalaires intégrées que vous pouvez utiliser dans les instructions CQL. Cette section fournit un aperçu de ces fonctions, y compris des exemples de leur utilisation. 

Tout au long de cette rubrique, vous trouverez une syntaxe détaillée, des exemples et les meilleures pratiques pour utiliser efficacement le CQL dans Amazon Keyspaces.

**Topics**
+ [Éléments du langage de requête Cassandra (CQL) dans Amazon Keyspaces](cql.elements.md)
+ [Instructions DDL (langage de définition des données) dans Amazon Keyspaces](cql.ddl.md)
+ [Instructions DML (langage de manipulation de données) dans Amazon Keyspaces](cql.dml.md)
+ [Fonctions intégrées dans Amazon Keyspaces](cql.functions.md)

# Éléments du langage de requête Cassandra (CQL) dans Amazon Keyspaces
<a name="cql.elements"></a>

Découvrez les éléments du langage de requête Cassandra (CQL) pris en charge par Amazon Keyspaces, notamment les identifiants, les constantes, les termes et les types de données.

**Topics**
+ [identifier](#cql.elements.identifier)
+ [constants](#cql.elements.constants)
+ [term](#cql.elements.term)
+ [Types de données](#cql.data-types)
+ [Encodage JSON des types de données Amazon Keyspaces](#cql.data-types.JSON)

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

Les identificateurs (ou noms) sont utilisés pour identifier les tables, colonnes et autres objets. Un identifiant peut être entre apostrophes ou pas. Les conditions suivantes s'appliquent :

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

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

Les constantes suivantes sont définies.

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

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

Un terme désigne le type de valeurs prises en charge. Les termes sont définis par ce qui suit.

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

## Types de données
<a name="cql.data-types"></a>

Amazon Keyspaces prend en charge les types de données suivants :

### Types de chaîne
<a name="cql.data-types.string"></a>


****  

| Type de données | Description | 
| --- | --- | 
|  `ascii`  | Représente une chaîne de caractères ASCII. | 
|  `text`  | Représente une chaîne encodée UTF-8. | 
|  `varchar`  |  Représente une chaîne encodée UTF-8 (`varchar` est un alias pour `text`).  | 

### Types numériques
<a name="cql.data-types.numeric"></a>


****  

| Type de données | Description | 
| --- | --- | 
|  `bigint`  | Représente un entier long signé 64 bits. | 
|  `counter`  | Représente un compteur d'entier signé 64 bits. Pour de plus amples informations, veuillez consulter [Compteurs](#cql.data-types.numeric.counters). | 
|  `decimal`  | Représente une décimale de précision variable. | 
|  `double`  | Représente une virgule flottante IEEE 754 64 bits. | 
|  `float`  | Représente une virgule flottante IEEE 754 32 bits. | 
|  `int`  |  Représente un entier signé 32 bits.  | 
|  `varint`  |  Représente une valeur entière comprise entre \$1/-10^38.  | 

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

Une colonne `counter` contient un entier signé 64 bits. La valeur du compteur est incrémentée ou décrémentée à l'aide de l'instruction [UPDATE](cql.dml.update.md), et ne peut pas être définie directement. Cela rend les colonnes `counter` utiles pour le suivi des dénombrements. Par exemple, vous pouvez utiliser des compteurs pour suivre le nombre d'entrées dans un fichier journal ou le nombre de fois qu'une publication a été consultée sur un réseau social. Les restrictions ci-après s'appliquent aux colonnes `counter` :
+ Une colonne de type `counter` ne peut pas faire partie de la `primary key` d'une table.
+ Dans une table qui contient une ou plusieurs colonnes de type `counter`, toutes les colonnes de cette table doivent être de type `counter`.

Dans les cas où la mise à jour d'un compteur échoue (par exemple, en raison d'un délai d'attente ou d'une perte de connexion avec Amazon Keyspaces), le client ne sait pas si la valeur du compteur a été mise à jour. Si la mise à jour est réessayée, la mise à jour de la valeur du compteur peut être appliquée une deuxième fois.

### Type de blob
<a name="cql.data-types.blob"></a>


****  

| Type de données | Description | 
| --- | --- | 
|  `blob`  | Représente les octets arbitraires. | 

### Type Boolean
<a name="cql.data-types.boolean"></a>


****  

| Type de données | Description | 
| --- | --- | 
|  `boolean`  | Représente true ou false. | 

### Types liés au temps
<a name="cql.data-types.time"></a>


****  

| Type de données | Description | 
| --- | --- | 
|  `date`  | Une chaîne au format<yyyy>-<mm>-<dd>. | 
|  `timestamp`  | Entier signé de 64 bits représentant la date et l'heure depuis l'époque (1er janvier 1970 à 00:00:00 GMT) en millisecondes. | 
|  `timeuuid`  | Représente un [UUID version 1](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)). | 

### Types de collections
<a name="cql.data-types.collection"></a>


****  

| Type de données | Description | 
| --- | --- | 
|  `list`  | Représente une collection ordonnée d'éléments littéraux. | 
|  `map`  | Représente une collection non ordonnée de paires clé-valeur. | 
|  `set`  | Représente une collection non ordonnée d'un ou plusieurs éléments littéraux. | 

Vous déclarez une colonne de collection en utilisant le type de collection suivi d'un autre type de données (par exemple, `TEXT` ou`INT`) entre crochets. Vous pouvez créer une colonne avec un `SET` de`TEXT`, ou vous pouvez créer des paires `INT` clé-valeur `TEXT` et un `MAP` of, comme indiqué dans l'exemple suivant.

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

Une collection *non figée* vous permet de mettre à jour chaque élément de collection individuel. Les horodatages côté client et les paramètres de durée de vie (TTL) sont enregistrés pour les éléments individuels.

Lorsque vous utilisez le `FROZEN` mot clé sur un type de collection, les valeurs de la collection sont sérialisées en une seule valeur immuable, et Amazon Keyspaces les traite comme un. `BLOB` Il s'agit d'une collection *surgelée*. Une `UPDATE` déclaration `INSERT` OR remplace l'ensemble de la collection Frozen. Vous ne pouvez pas mettre à jour des éléments individuels d'une collection figée.

Les paramètres d'horodatage et de durée de vie (TTL) côté client s'appliquent à l'ensemble de la collection figée, et non à des éléments individuels. `Frozen`les colonnes de collection peuvent faire partie `PRIMARY KEY` d'un tableau.

Vous pouvez imbriquer des collections congelées. Par exemple, vous pouvez définir un `MAP` dans un `SET` si le `FROZEN` mot clé `MAP` est utilisé, comme illustré dans l'exemple suivant. 

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

Amazon Keyspaces prend en charge l'imbrication d'un maximum de 8 niveaux de collections figées par défaut. Pour de plus amples informations, veuillez consulter [Quotas de service Amazon Keyspaces](quotas.md#table). Pour plus d'informations sur les différences fonctionnelles avec Apache Cassandra, consultez[`FROZEN`collections](functional-differences.md#functional-differences.frozen-collections). Pour plus d'informations sur la syntaxe CQL, consultez [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create) et[ALTER TABLE](cql.ddl.table.md#cql.ddl.table.alter).

### Type de tuple
<a name="cql.data-types.tuple"></a>

Le type de `tuple` données représente un groupe limité d'éléments littéraux. Vous pouvez utiliser un tuple comme alternative à un`user defined type`. Il n'est pas nécessaire d'utiliser le `FROZEN` mot-clé pour les tuples. En effet, un tuple est toujours figé et vous ne pouvez pas mettre à jour les éléments individuellement. 

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


****  

| Type de données | Description | 
| --- | --- | 
|  `inet`  | Chaîne représentant une adresse IP, au IPv6 format IPv4 ou au format. | 

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

Dans un tableau Amazon Keyspaces avec des colonnes de regroupement, vous pouvez utiliser le `STATIC` mot clé pour créer une colonne statique de n'importe quel type. 

La déclaration suivante en est un exemple.

```
my_column INT STATIC
```

Pour plus d'informations sur l'utilisation de colonnes statiques, consultez[Estimation de la consommation de capacité pour les colonnes statiques dans Amazon Keyspaces](static-columns.md).

### Types définis par l'utilisateur () UDTs
<a name="cql.data-types.user-defined"></a>

Amazon Keyspaces prend en charge les types définis par l'utilisateur (). UDTs Vous pouvez utiliser n'importe quel type de données Amazon Keyspaces valide pour créer un UDT, y compris les collections et autres données existantes. UDTs Vous créez UDTs dans un espace de touches et vous pouvez les utiliser pour définir des colonnes dans n'importe quel tableau de l'espace de touches.

Pour plus d'informations sur la syntaxe CQL, consultez[Types définis par l'utilisateur () UDTs](cql.ddl.type.md). Pour plus d'informations sur l'utilisation UDTs, consultez[Types définis par l'utilisateur (UDTs) dans Amazon Keyspaces](udts.md).

Pour connaître le nombre de valeurs UDTs prises en charge par espace de touches, les niveaux d'imbrication pris en charge, ainsi que les autres valeurs par défaut et quotas associés UDTs, voir. [Quotas et valeurs par défaut pour les types définis par l'utilisateur (UDTs) dans Amazon Keyspaces](quotas.md#quotas-udts)

## Encodage JSON des types de données Amazon Keyspaces
<a name="cql.data-types.JSON"></a>

Amazon Keyspaces propose les mêmes mappages de types de données JSON qu'Apache Cassandra. Le tableau suivant décrit les types de données qu'Amazon Keyspaces accepte dans les `INSERT JSON` instructions et les types de données qu'Amazon Keyspaces utilise lorsqu'il renvoie des données avec l'instruction. `SELECT JSON`

Pour les types de données à champ unique tels que `float``int`,`UUID`, et`date`, vous pouvez également insérer des données sous forme de`string`. Pour les types de données composés et les collections, tels que `tuple``map`, et`list`, vous pouvez également insérer des données au format JSON ou sous forme codée`JSON string`.


****  

| Type de données JSON | Types de données acceptés dans les `INSERT JSON` relevés | Types de données renvoyés dans les `SELECT JSON` relevés | Remarques | 
| --- | --- | --- | --- | 
|  `ascii`  | string | string | Utilise l'échappement de caractères JSON`\u`. | 
|  `bigint`  | integer, string | integer | La chaîne doit être un entier de 64 bits valide. | 
|  `blob`  | string | string | La chaîne doit commencer `0x` par un nombre pair de chiffres hexadécimaux. | 
|  `boolean`  | boolean, string | boolean | La chaîne doit être l'une `true` ou l'autre`false`. | 
|  `date`  | string | string | Date au format`YYYY-MM-DD`, fuseau horaire UTC. | 
|  `decimal`  | integer, float, string | float | Peut dépasser la précision à virgule flottante IEEE-754 32 bits ou 64 bits dans le décodeur côté client. | 
|  `double`  | integer, float, string | float | La chaîne doit être un entier ou un nombre flottant valide. | 
|  `float`  | integer, float, string | float | La chaîne doit être un entier ou un nombre flottant valide. | 
|  `inet`  | string | string | IPv4 ou IPv6 adresse. | 
|  `int`  | integer, string | integer | La chaîne doit être un entier 32 bits valide. | 
|  `list`  | list, string | list | Utilise la représentation de liste JSON native. | 
|  `map`  | map, string | map | Utilise la représentation cartographique JSON native. | 
|  `smallint`  | integer, string | integer | La chaîne doit être un entier de 16 bits valide. | 
|  `set`  | list, string | list | Utilise la représentation de liste JSON native. | 
|  `text`  | string | string | Utilise l'échappement de caractères JSON`\u`. | 
|  `time`  | string | string | Heure du jour au format`HH-MM-SS[.fffffffff]`. | 
|  `timestamp`  | integer, string | string | Horodatage. Les constantes de chaîne vous permettent de stocker des horodatages sous forme de dates. Les horodatages avec format `YYYY-MM-DD HH:MM:SS.SSS` sont renvoyés. | 
|  `timeuuid`  | string | string | Tapez 1 UUID. Voir [constants](#cql.elements.constants) pour le format UUID. | 
|  `tinyint`  | integer, string | integer | La chaîne doit être un entier de 8 bits valide. | 
|  `tuple`  | list, string | list | Utilise la représentation de liste JSON native. | 
|  `UDT`  | map, string | map | Utilise la représentation cartographique JSON native avec les noms de champs comme clés. | 
|  `uuid`  | string | string | Voir [constants](#cql.elements.constants) pour le format UUID. | 
|  `varchar`  | string | string | Utilise l'échappement de caractères JSON`\u`. | 
|  `varint`  | integer, string | integer | Longueur variable ; peut dépasser les nombres entiers de 32 bits ou 64 bits dans le décodeur côté client. | 

# Instructions DDL (langage de définition des données) dans Amazon Keyspaces
<a name="cql.ddl"></a>

Le *langage de définition des données* (DDL) est l'ensemble des instructions Cassandra Query Language (CQL) que vous utilisez pour gérer les structures de données dans Amazon Keyspaces (pour Apache Cassandra), telles que les espaces de touches et les tables. Vous utilisez DDL pour créer ces structures de données, les modifier après leur création et les supprimer lorsqu'elles ne sont plus utilisées. Amazon Keyspaces exécute des opérations DDL de manière asynchrone. Pour plus d'informations sur la façon de confirmer qu'une opération asynchrone est terminée, consultez. [Création et suppression asynchrones d'espaces clés et de tables](functional-differences.md#functional-differences.table-keyspace-management)

 Les instructions DDL suivantes sont prises en charge : 
+  [CREATE KEYSPACE](cql.ddl.keyspace.md#cql.ddl.keyspace.create) 
+  [ALTER KEYSPACE](cql.ddl.keyspace.md#cql.ddl.keyspace.alter) 
+  [DROP KEYSPACE](cql.ddl.keyspace.md#cql.ddl.keyspace.drop) 
+  [UTILISER](cql.ddl.keyspace.md#cql.ddl.keyspace.use) 
+  [CRÉER UNE TABLE](cql.ddl.table.md#cql.ddl.table.create) 
+  ALTER TABLE 
+  [RESTAURER LA TABLE](cql.ddl.table.md#cql.ddl.table.restore) 
+  [SUPPRIMER LA TABLE](cql.ddl.table.md#cql.ddl.table.drop) 
+  [CRÉER UN TYPE](cql.ddl.type.md#cql.ddl.type.create) 
+  [TYPE DE CHUTE](cql.ddl.type.md#cql.ddl.type.drop) 

**Topics**
+ [Keyspaces](cql.ddl.keyspace.md)
+ [Tables](cql.ddl.table.md)
+ [Types définis par l'utilisateur () UDTs](cql.ddl.type.md)

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

Un *keyspace* regroupe les tables associées qui sont pertinentes pour une ou plusieurs applications. En termes de système de gestion de base de données relationnelle (SGBDR), les keyspaces sont à peu près similaires aux bases de données, tablespaces ou constructions similaires.

**Note**  
Dans Apache Cassandra, les keyspaces déterminent la réplique des données entre plusieurs nœuds de stockage. Cependant, Amazon Keyspaces est un service entièrement géré : les détails de sa couche de stockage sont gérés en votre nom. Pour cette raison, les espaces clés d'Amazon Keyspaces sont uniquement des constructions logiques et ne sont pas liés au stockage physique sous-jacent.

Pour plus d'informations sur les limites de quota et les contraintes pour les espaces de clés Amazon Keyspaces, consultez. [Quotas pour Amazon Keyspaces (pour Apache Cassandra)](quotas.md)

**Topics**
+ [CREATE KEYSPACE](#cql.ddl.keyspace.create)
+ [ALTER KEYSPACE](#cql.ddl.keyspace.alter)
+ [DROP KEYSPACE](#cql.ddl.keyspace.drop)
+ [USE](#cql.ddl.keyspace.use)

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

Utilisez l'instruction `CREATE KEYSPACE` pour créer un nouveau keyspace.

**Syntaxe**

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

Où :
+ `keyspace_name` est le nom du keyspace à créer.
+ Les *options* peuvent être les suivantes :
  + `REPLICATION`— Une carte qui indique la stratégie de réplication pour le keyspace :
    + `SingleRegionStrategy`— Pour un keyspace à région unique. (Obligatoire)
    + `NetworkTopologyStrategy`— Spécifiez au moins deux Régions AWS. Le facteur de réplication pour chaque région est de trois. (Facultatif)
  + `DURABLE_WRITES`— Les écritures sur Amazon Keyspaces sont toujours durables, cette option n'est donc pas requise. Toutefois, si elle est spécifiée, la valeur doit être `true`.
  + `TAGS`— Une liste de balises de paires clé-valeur à associer à la ressource lorsque vous la créez. (Facultatif)

**Exemple**

Créez un keyspace comme suit.

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

Pour créer un espace de touches multirégional, spécifiez-en `NetworkTopologyStrategy` et incluez-en au moins deux. Régions AWS Le facteur de réplication pour chaque région est de trois.

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

## ALTER KEYSPACE
<a name="cql.ddl.keyspace.alter"></a>

Vous pouvez utiliser l'`ALTER KEYSPACE WITH`instruction pour les *options* suivantes
+ `REPLICATION`— Utilisez cette option pour ajouter une nouvelle Région AWS réplique à un keyspace. Vous pouvez ajouter une nouvelle région à un keyspace à région unique ou multirégional. 
+ `TAGS`— Utilisez cette option pour ajouter ou supprimer des balises dans un espace de touches.

**Syntaxe**

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

Où :
+ `keyspace_name` est le nom du keyspace à modifier.
+ *les options* sont l'une des suivantes :
  + `ADD | DROP TAGS`— Une liste de balises de paires clé-valeur à ajouter ou à supprimer de l'espace clé. 
  + `REPLICATION`— Une carte qui indique la stratégie de réplication pour le keyspace ; 
    + `class`— `NetworkTopologyStrategy` définit le keyspace comme étant un keyspace multirégional.
    + `region`— Spécifiez une touche supplémentaire Région AWS pour cet espace de touches. Le facteur de réplication pour chaque région est de trois.
    + `CLIENT_SIDE_TIMESTAMPS`— La valeur par défaut est`DISABLED`. Vous ne pouvez modifier le statut que sur`ENABLED`.

**Exemples**

Modifiez un espace de touche comme indiqué dans l'exemple suivant pour ajouter des balises.

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

Pour ajouter une troisième région à un espace de touches multirégional, vous pouvez utiliser l'instruction suivante.

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

## DROP KEYSPACE
<a name="cql.ddl.keyspace.drop"></a>

Utilisez l'`DROP KEYSPACE`instruction pour supprimer un espace de touches, y compris l'ensemble de son contenu, tel que les tableaux.

**Syntaxe**

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

Où :
+ *keyspace\$1name* est le nom du keyspace à supprimer.

**Exemple**

```
DROP KEYSPACE my_keyspace;
```

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

Utilisez l'`USE`instruction pour définir le keyspace actuel. Cela vous permet de faire référence à des objets liés à un espace de touches spécifique, par exemple des tables et des types, sans utiliser le nom complet qui inclut le préfixe d'espace-clé. 

**Syntaxe**

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

Où :
+ *keyspace\$1name* est le nom du keyspace à utiliser.

**Exemple**

```
USE my_keyspace;
```

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

Les *tables* sont les principales structures de données d'Amazon Keyspaces. Les données d'une table sont organisées en lignes et en colonnes. Un sous-ensemble de ces colonnes est utilisé pour déterminer le partitionnement (et finalement le placement des données) via la spécification d'une clé de partition.

Un autre ensemble de colonnes peut être défini en colonnes de clustering, ce qui signifie qu'elles peuvent participer en tant que prédicats à l'exécution de la requête. 

Par défaut, de nouvelles tables sont créées avec une capacité de débit *à la demande*. Vous pouvez modifier le mode de capacité pour les tables nouvelles et existantes. Pour plus d'informations sur les modes read/write de débit de capacité, consultez[Configurer les modes de read/write capacité dans Amazon Keyspaces](ReadWriteCapacityMode.md). 

Pour les tables en mode provisionné, vous pouvez configurer en option`AUTOSCALING_SETTINGS`. Pour plus d'informations sur le dimensionnement automatique d'Amazon Keyspaces et les options disponibles, consultez. [Configurer le dimensionnement automatique sur une table existante](autoscaling.configureTable.md)

Pour plus d'informations sur les limites de quota et les contraintes pour les tables Amazon Keyspaces, consultez. [Quotas pour Amazon Keyspaces (pour Apache Cassandra)](quotas.md)

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

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

Utilisez l'instruction `CREATE TABLE` pour créer une nouvelle table.

 **Syntaxe**

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

Où :
+ `table_name` est le nom de la table à créer. Le nom complet inclut le préfixe keyspace. Vous pouvez également définir le keyspace actuel à l'aide de l'instruction `USE` keyspace.
+ `column_definition` comprend les éléments suivants :
  +  *`column_name`*— Le nom de la colonne.
  + `cql_type`— Un type de données Amazon Keyspaces (voir[Types de données](cql.elements.md#cql.data-types)).
  + `FROZEN`— Désigne cette colonne définie par l'utilisateur ou de type `collection` (par exemple, `LIST``SET`, ou`MAP`) comme figée. Une collection *figée* est sérialisée en une seule valeur immuable et traitée comme une. `BLOB` Pour de plus amples informations, veuillez consulter [Types de collections](cql.elements.md#cql.data-types.collection).
  + `STATIC`— Désigne cette colonne comme statique. Les colonnes statiques stockent les valeurs partagées par toutes les lignes d'une même partition.
  + `PRIMARY KEY`— Désigne cette colonne comme clé primaire de la table.
+ `primary_key` comprend les éléments suivants :
  + `partition_key`
  + `clustering_columns`
+ `partition_key`:
  + La clé de partition peut être une seule colonne ; il peut aussi s'agir d'une valeur composée de deux colonnes ou plus. La partie clé de partition de la clé primaire est obligatoire et détermine la manière dont Amazon Keyspaces stocke vos données. 
+ `clustering_columns`:
  + La partie facultative de la colonne de clustering de votre clé primaire détermine la façon dont les données sont regroupées et triées dans chaque partition. 
+ `table_options`se composent des éléments suivants :
  + *`CLUSTERING ORDER BY`*— L'ORDRE DE CLUSTERING par défaut sur une table est composé de vos clés de clustering dans le sens de `ASC` tri (croissant). Spécifiez-le pour remplacer le comportement de tri par défaut. 
  +  *`cdc`*— Un booléen qui indique si Amazon Keyspaces crée un flux de capture des données de modification (CDC) pour la table. La valeur par défaut est `false`. Pour spécifier le `view type` lors de l'activation d'un flux, définissez le `cdc_specification` avec`CUSTOM_PROPERTIES`. 
  +  *`CUSTOM_PROPERTIES`*— Une carte des paramètres spécifiques à Amazon Keyspaces.
    +  `capacity_mode`: spécifie le mode de capacité de débit en lecture/écriture pour la table. Les options sont `throughput_mode:PAY_PER_REQUEST` et `throughput_mode:PROVISIONED`. Le mode de capacité allouée nécessite `read_capacity_units` et `write_capacity_units` en tant qu'entrées. La valeur par défaut est `throughput_mode:PAY_PER_REQUEST`.
    +  `cdc_specification`: Spécifie `view_type` le flux CDC. Les options sont :
      + `NEW_AND_OLD_IMAGES`— les deux versions de la ligne, avant et après la modification. Il s’agit de l’option par défaut.
      + `NEW_IMAGE`— la version de la ligne après la modification.
      + `OLD_IMAGE`— la version de la ligne avant la modification.
      + `KEYS_ONLY`— les clés de partition et de clustering de la ligne qui a été modifiée.

      Pour plus d'informations sur les flux CDC, consultez[Utilisation des flux de capture des données modifiées (CDC) dans Amazon Keyspaces](cdc.md). Pour des exemples de code, consultez [Activer un flux CDC lors de la création d'une nouvelle table dans Amazon Keyspaces](keyspaces-enable-cdc-new-table.md).
    +  `client_side_timestamps`: Spécifie si les horodatages côté client sont activés ou désactivés pour la table. Les options sont `{'status': 'enabled'}` et `{'status': 'disabled'}`. S'il n'est pas spécifié, la valeur par défaut est`status:disabled`. Une fois les horodatages côté client activés pour une table, ce paramètre ne peut pas être désactivé. 
    +  `encryption_specification`: Spécifie les options de chiffrement pour le chiffrement au repos. S'il n'est pas spécifié, la valeur par défaut est`encryption_type:AWS_OWNED_KMS_KEY`. L'option de chiffrement (clé gérée par le client) nécessite la AWS KMS clé au format Amazon Resource Name (ARN) comme entrée : `kms_key_identifier:ARN` :`kms_key_identifier:ARN`. 
    +  `point_in_time_recovery`: Spécifie si point-in-time la restauration est activée ou désactivée pour la table. Les options sont `status:enabled` et `status:disabled`. S'il n'est pas spécifié, la valeur par défaut est`status:disabled`.
    + `replica_updates`: Spécifie les paramètres d'une table multirégionale spécifiques à un Région AWS. Pour une table multirégionale, vous pouvez configurer la capacité de lecture de la table différemment selon Région AWS les régions. Vous pouvez le faire en configurant les paramètres suivants. Pour plus d’informations et d’exemples, consultez [Création d'une table multirégionale en mode provisionné avec mise à l'échelle automatique dans Amazon Keyspaces](tables-mrr-create-provisioned.md).
      + `region`— La réplique Région AWS de la table avec les paramètres suivants :
        + `read_capacity_units`
    +  `TTL`: active les paramètres personnalisés Time to Live pour le tableau. Pour l'activer, utilisez`status:enabled`. La valeur par défaut est `status:disabled`. Une fois `TTL` activé, vous ne pouvez pas le désactiver pour le tableau.
  + `AUTOSCALING_SETTINGS`inclut les paramètres facultatifs suivants pour les tables en mode provisionné. Pour plus d’informations et d’exemples, consultez [Création d'un nouveau tableau avec mise à l'échelle automatique](autoscaling.createTable.md).
    + `provisioned_write_capacity_autoscaling_update`:
      + `autoscaling_disabled`— Pour activer la mise à l'échelle automatique en fonction de la capacité d'écriture, définissez la valeur sur`false`. La valeur par défaut est `true`. (Facultatif)
      + `minimum_units`— Le niveau minimum de débit d'écriture que la table doit toujours être prête à prendre en charge. La valeur doit être comprise entre 1 et le quota de débit maximal par seconde pour votre compte (40 000 par défaut).
      + `maximum_units`— Le niveau maximal de débit d'écriture que la table doit toujours être prête à prendre en charge. La valeur doit être comprise entre 1 et le quota de débit maximal par seconde pour votre compte (40 000 par défaut).
      + `scaling_policy`— Amazon Keyspaces soutient la politique de suivi des cibles. La cible de dimensionnement automatique est la capacité d'écriture allouée à la table.
        + `target_tracking_scaling_policy_configuration`— Pour définir la politique de suivi de la cible, vous devez définir la valeur cible. Pour plus d'informations sur le suivi des cibles et les périodes de recharge, consultez les [politiques de dimensionnement de Target Tracking](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) dans le *guide de l'utilisateur d'Application Auto Scaling*. 
          + `target_value`— Le taux d'utilisation cible de la table. Le dimensionnement automatique d'Amazon Keyspaces garantit que le rapport entre la capacité consommée et la capacité allouée reste égal ou proche de cette valeur. Vous définissez `target_value` en tant que pourcentage. Un double entre 20 et 90. (Obligatoire)
          + `scale_in_cooldown`— Un temps de recharge en secondes entre les activités de mise à l'échelle, qui permet à la table de se stabiliser avant qu'une autre activité d'échelle ne commence. Si aucune valeur n'est fournie, la valeur par défaut est 0. (Facultatif)
          + `scale_out_cooldown`— Un temps de recharge en secondes entre les activités de redimensionnement qui permet à la table de se stabiliser avant le début d'une autre activité de redimensionnement. Si aucune valeur n'est fournie, la valeur par défaut est 0. (Facultatif)
          + `disable_scale_in`: A `boolean` qui indique si la table `scale-in` est désactivée ou activée. Ce paramètre est désactivé par défaut. Pour l'activer`scale-in`, définissez la `boolean` valeur sur`FALSE`. Cela signifie que la capacité est automatiquement réduite pour une table en votre nom. (Facultatif) 
    + `provisioned_read_capacity_autoscaling_update`:
      + `autoscaling_disabled`— Pour activer la mise à l'échelle automatique en fonction de la capacité de lecture, définissez la valeur sur`false`. La valeur par défaut est `true`. (Facultatif)
      + `minimum_units`— Le niveau de débit minimal que la table doit toujours être prête à prendre en charge. La valeur doit être comprise entre 1 et le quota de débit maximal par seconde pour votre compte (40 000 par défaut).
      + `maximum_units`— Le niveau de débit maximal que la table doit toujours être prête à supporter. La valeur doit être comprise entre 1 et le quota de débit maximal par seconde pour votre compte (40 000 par défaut).
      + `scaling_policy`— Amazon Keyspaces soutient la politique de suivi des cibles. L'objectif de dimensionnement automatique est la capacité de lecture allouée à la table.
        + `target_tracking_scaling_policy_configuration`— Pour définir la politique de suivi de la cible, vous devez définir la valeur cible. Pour plus d'informations sur le suivi des cibles et les périodes de recharge, consultez les [politiques de dimensionnement de Target Tracking](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) dans le *guide de l'utilisateur d'Application Auto Scaling*. 
          + `target_value`— Le taux d'utilisation cible de la table. Le dimensionnement automatique d'Amazon Keyspaces garantit que le rapport entre la capacité consommée et la capacité allouée reste égal ou proche de cette valeur. Vous définissez `target_value` en tant que pourcentage. Un double entre 20 et 90. (Obligatoire)
          + `scale_in_cooldown`— Un temps de recharge en secondes entre les activités de mise à l'échelle, qui permet à la table de se stabiliser avant qu'une autre activité d'échelle ne commence. Si aucune valeur n'est fournie, la valeur par défaut est 0. (Facultatif)
          + `scale_out_cooldown`— Un temps de recharge en secondes entre les activités de redimensionnement qui permet à la table de se stabiliser avant le début d'une autre activité de redimensionnement. Si aucune valeur n'est fournie, la valeur par défaut est 0. (Facultatif)
          + `disable_scale_in`: A `boolean` qui indique si la table `scale-in` est désactivée ou activée. Ce paramètre est désactivé par défaut. Pour l'activer`scale-in`, définissez la `boolean` valeur sur`FALSE`. Cela signifie que la capacité est automatiquement réduite pour une table en votre nom. (Facultatif) 
    + `replica_updates`: Spécifie les paramètres de mise à l'échelle automatique Région AWS spécifiques d'une table multirégionale. Pour une table multirégionale, vous pouvez configurer la capacité de lecture de la table différemment selon Région AWS les régions. Vous pouvez le faire en configurant les paramètres suivants. Pour plus d’informations et d’exemples, consultez [Mettre à jour les paramètres de capacité allouée et de dimensionnement automatique pour une table multirégionale dans Amazon Keyspaces](tables-mrr-autoscaling.md).
      + `region`— La réplique Région AWS de la table avec les paramètres suivants :
        + `provisioned_read_capacity_autoscaling_update`
          + `autoscaling_disabled`— Pour activer la mise à l'échelle automatique en fonction de la capacité de lecture de la table, définissez la valeur sur`false`. La valeur par défaut est `true`. (Facultatif) 
**Note**  
La mise à l'échelle automatique d'une table multirégionale doit être activée ou désactivée pour toutes les répliques de la table.
          + `minimum_units`— Le niveau minimum de débit de lecture que la table doit toujours être prête à prendre en charge. La valeur doit être comprise entre 1 et le quota de débit maximal par seconde pour votre compte (40 000 par défaut).
          + `maximum_units`— Le niveau maximal de débit de lecture que la table doit toujours être prête à prendre en charge. La valeur doit être comprise entre 1 et le quota de débit maximal par seconde pour votre compte (40 000 par défaut).
          + `scaling_policy`— Amazon Keyspaces soutient la politique de suivi des cibles. L'objectif de dimensionnement automatique est la capacité de lecture allouée à la table.
            + `target_tracking_scaling_policy_configuration`— Pour définir la politique de suivi de la cible, vous devez définir la valeur cible. Pour plus d'informations sur le suivi des cibles et les périodes de recharge, consultez les [politiques de dimensionnement de Target Tracking](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html) dans le *guide de l'utilisateur d'Application Auto Scaling*. 
              + `target_value`— Le taux d'utilisation cible de la table. Le dimensionnement automatique d'Amazon Keyspaces garantit que le rapport entre la capacité de lecture consommée et la capacité de lecture allouée reste égal ou proche de cette valeur. Vous définissez `target_value` en tant que pourcentage. Un double entre 20 et 90. (Obligatoire)
              + `scale_in_cooldown`— Un temps de recharge en secondes entre les activités de mise à l'échelle, qui permet à la table de se stabiliser avant qu'une autre activité d'échelle ne commence. Si aucune valeur n'est fournie, la valeur par défaut est 0. (Facultatif)
              + `scale_out_cooldown`— Un temps de recharge en secondes entre les activités de redimensionnement qui permet à la table de se stabiliser avant le début d'une autre activité de redimensionnement. Si aucune valeur n'est fournie, la valeur par défaut est 0. (Facultatif)
              + `disable_scale_in`: A `boolean` qui indique si la table `scale-in` est désactivée ou activée. Ce paramètre est désactivé par défaut. Pour l'activer`scale-in`, définissez la `boolean` valeur sur`FALSE`. Cela signifie que la capacité de lecture est automatiquement réduite pour une table en votre nom. (Facultatif) 
  + `default_time_to_live`— Le paramètre Durée de vie par défaut en secondes pour le tableau.
  + `TAGS`— Une liste de balises de paires clé-valeur à associer à la ressource lors de sa création. 
  + `clustering_order` comprend les éléments suivants :
    +  *`column_name`*— Le nom de la colonne. 
    +  *`ASC | DESC`*— Définit le modificateur d'ordre ascendant (`ASC`) ou descendant (`DESC`). S'il n'est pas spécifié, l'ordre par défaut est ASC. 

**Exemple**

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

Dans une table qui utilise des colonnes de clustering, les colonnes non clusterisées peuvent être déclarées statiques dans la définition de la table. Pour plus d'informations sur les colonnes statiques, consultez[Estimation de la consommation de capacité pour les colonnes statiques dans Amazon Keyspaces](static-columns.md).

**Exemple**

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

Vous pouvez créer une table avec une colonne utilisant un type défini par l'utilisateur (UDT). La première instruction des exemples crée un type, la seconde crée une table avec une colonne qui utilise le type.

**Exemple**

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

Utilisez l'`ALTER TABLE`instruction pour ajouter de nouvelles colonnes, ajouter des balises ou modifier les propriétés personnalisées du tableau.

**Syntaxe**

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

Où :
+ `table_name` est le nom de la table à modifier.
+ `column_definition` est le nom de la colonne et le type de données à ajouter.
+ `column_definition_list` est une liste de colonnes séparées par des virgules placées entre parenthèses.
+ `table_options`se composent des éléments suivants :
  + `AUTOSCALING_SETTINGS`inclut les paramètres de mise à l'échelle automatique facultatifs pour les tables provisionnées. Pour la syntaxe et les descriptions détaillées, voir[CREATE TABLE](#cql.ddl.table.create). Pour obtenir des exemples, consultez [Configurer le dimensionnement automatique sur une table existante](autoscaling.configureTable.md).
  +  *`cdc`*— Un booléen qui indique si Amazon Keyspaces crée un flux de capture des données de modification (CDC) pour la table. La valeur par défaut est `false`. Pour spécifier le `view type` lors de l'activation d'un flux, définissez le `cdc_specification` avec`CUSTOM_PROPERTIES`. 
  +  *`CUSTOM_PROPERTIES`*— Une carte des paramètres spécifiques à Amazon Keyspaces.
    +  `capacity_mode`: spécifie le mode de capacité de débit en lecture/écriture pour la table. Les options sont `throughput_mode:PAY_PER_REQUEST` et `throughput_mode:PROVISIONED`. Le mode de capacité allouée nécessite `read_capacity_units` et `write_capacity_units` en tant qu'entrées. La valeur par défaut est `throughput_mode:PAY_PER_REQUEST`.
    +  `cdc_specification`: Spécifie `view_type` le flux CDC. Les options sont :
      + `NEW_AND_OLD_IMAGES`— les deux versions de la ligne, avant et après la modification. Il s’agit de l’option par défaut.
      + `NEW_IMAGE`— la version de la ligne après la modification.
      + `OLD_IMAGE`— la version de la ligne avant la modification.
      + `KEYS_ONLY`— les clés de partition et de clustering de la ligne qui a été modifiée.

      Pour plus d'informations sur les flux CDC, consultez[Utilisation des flux de capture des données modifiées (CDC) dans Amazon Keyspaces](cdc.md). Pour des exemples de code, consultez [Activer un flux CDC pour une table existante dans Amazon Keyspaces](keyspaces-enable-cdc-alter-table.md).
    +  `client_side_timestamps`: Spécifie si les horodatages côté client sont activés ou désactivés pour la table. Les options sont `{'status': 'enabled'}` et `{'status': 'disabled'}`. S'il n'est pas spécifié, la valeur par défaut est`status:disabled`. Une fois les horodatages côté client activés pour une table, ce paramètre ne peut pas être désactivé. 
    +  `encryption_specification`: Spécifie l'option de chiffrement pour le chiffrement au repos. Les options sont `encryption_type:AWS_OWNED_KMS_KEY` et `encryption_type:CUSTOMER_MANAGED_KMS_KEY`. L'option de chiffrement (clé gérée par le client) nécessite la AWS KMS clé au format Amazon Resource Name (ARN) comme entrée :`kms_key_identifier:ARN`. 
    +  `point_in_time_recovery`: Spécifie si point-in-time la restauration est activée ou désactivée pour la table. Les options sont `status:enabled` et `status:disabled`. La valeur par défaut est `status:disabled`.
    + `replica_updates`: Spécifie les paramètres Région AWS spécifiques d'une table multirégionale. Pour une table multirégionale, vous pouvez configurer la capacité de lecture de la table différemment selon Région AWS les régions. Vous pouvez le faire en configurant les paramètres suivants. Pour plus d’informations et d’exemples, consultez [Mettre à jour les paramètres de capacité allouée et de dimensionnement automatique pour une table multirégionale dans Amazon Keyspaces](tables-mrr-autoscaling.md).
      + `region`— La réplique Région AWS de la table avec les paramètres suivants :
        + `read_capacity_units` 
    +  `ttl`: active les paramètres personnalisés Time to Live pour le tableau. Pour l'activer, utilisez`status:enabled`. La valeur par défaut est `status:disabled`. Une fois `ttl` activé, vous ne pouvez pas le désactiver pour le tableau.
+ `default_time_to_live`: paramètre de durée de vie par défaut en secondes pour le tableau.
+ `TAGS` est une liste de balises de paire clé-valeur à attacher à la ressource.

**Note**  
Avec ALTER TABLE, vous ne pouvez modifier qu'une seule propriété personnalisée. Vous ne pouvez pas combiner plusieurs commandes ALTER TABLE dans la même instruction.

**Exemples**

L'instruction suivante indique comment ajouter une colonne à une table existante.

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

Cette instruction indique comment ajouter deux colonnes de collection à une table existante : 
+ Colonne de collection figée `col_frozen_list` contenant une collection figée imbriquée
+ Colonne de collection non figée `col_map` contenant une collection figée imbriquée

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

L'exemple suivant montre comment ajouter une colonne utilisant un type défini par l'utilisateur (UDT) à une table.

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

Pour modifier le mode de capacité d'une table et spécifier les unités de capacité de lecture et d'écriture, vous pouvez utiliser l'instruction suivante.

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

L'instruction suivante indique une clé KMS gérée par le client pour la table.

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

Pour activer point-in-time la restauration d'une table, vous pouvez utiliser l'instruction suivante.

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

Pour définir une valeur Time to Live par défaut en secondes pour une table, vous pouvez utiliser l'instruction suivante.

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

Cette instruction active les paramètres Time to Live personnalisés pour une table.

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

## RESTAURER LA TABLE
<a name="cql.ddl.table.restore"></a>

Utilisez l'`RESTORE TABLE`instruction pour rétablir une table à un point précis dans le temps. Cette instruction nécessite que la point-in-time restauration soit activée sur une table. Pour de plus amples informations, veuillez consulter [Backup et restauration des données avec point-in-time restauration pour Amazon Keyspaces](PointInTimeRecovery.md).

**Syntaxe**

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

Où :
+ `restored_table_name`est le nom de la table restaurée.
+ `source_table_name`est le nom de la table source.
+ `table_options` comprend les éléments suivants :
  + `restore_timestamp`est l'heure du point de restauration au format ISO 8601. S'il n'est pas spécifié, l'horodatage actuel est utilisé.
  +  *`CUSTOM_PROPERTIES`*— Une carte des paramètres spécifiques à Amazon Keyspaces.
    +  `capacity_mode`: spécifie le mode de capacité de débit en lecture/écriture pour la table. Les options sont `throughput_mode:PAY_PER_REQUEST` et `throughput_mode:PROVISIONED`. Le mode de capacité allouée nécessite `read_capacity_units` et `write_capacity_units` en tant qu'entrées. La valeur par défaut est le paramètre actuel de la table source.
    +  `encryption_specification`: Spécifie l'option de chiffrement pour le chiffrement au repos. Les options sont `encryption_type:AWS_OWNED_KMS_KEY` et `encryption_type:CUSTOMER_MANAGED_KMS_KEY`. L'option de chiffrement (clé gérée par le client) nécessite la AWS KMS clé au format Amazon Resource Name (ARN) comme entrée :`kms_key_identifier:ARN`. Pour restaurer une table chiffrée avec une clé gérée par le client vers une table chiffrée avec un Clé détenue par AWS, Amazon Keyspaces a besoin d'accéder à la AWS KMS clé de la table source.
    +  `point_in_time_recovery`: Spécifie si point-in-time la restauration est activée ou désactivée pour la table. Les options sont `status:enabled` et `status:disabled`. Contrairement à ce qui se passe lorsque vous créez de nouvelles tables, le statut par défaut des tables restaurées est `status:enabled` dû au fait que le paramètre est hérité de la table source. Pour désactiver le PITR pour les tables restaurées, vous devez définir `status:disabled` explicitement.
    + `replica_updates`: Spécifie les paramètres Région AWS spécifiques d'une table multirégionale. Pour une table multirégionale, vous pouvez configurer la capacité de lecture de la table différemment selon Région AWS les régions. Vous pouvez le faire en configurant les paramètres suivants. 
      + `region`— La réplique Région AWS de la table avec les paramètres suivants :
        + `read_capacity_units` 
  + `AUTOSCALING_SETTINGS`inclut les paramètres de mise à l'échelle automatique facultatifs pour les tables provisionnées. Pour une syntaxe et des descriptions détaillées, voir[CREATE TABLE](#cql.ddl.table.create).
  + `TAGS` est une liste de balises de paire clé-valeur à attacher à la ressource.

**Note**  
Les tables supprimées ne peuvent être restaurées qu'au moment de leur suppression.

**Exemple**

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

Utilisez l'instruction `DROP TABLE` pour supprimer une table du keyspace.

**Syntaxe**

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

Où :
+ `IF EXISTS` empêche `DROP TABLE` d'échouer si la table n'existe pas. (Facultatif)
+ `table_name` est le nom de la table à supprimer.

**Exemple**

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

# Types définis par l'utilisateur () UDTs
<a name="cql.ddl.type"></a>

*UDT* : regroupement de champs et de types de données que vous pouvez utiliser pour définir une seule colonne dans Amazon Keyspaces. Les types de données valides pour UDTs sont tous les types de données Cassandra pris en charge, y compris les collections et les autres UDTs que vous avez déjà créées dans le même keyspace. Pour plus d'informations sur les types de données Cassandra pris en charge, consultez[Support des types de données 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>

Utilisez l'`CREATE TYPE`instruction pour créer un nouveau type.

 **Syntaxe**

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

Où :
+ `IF NOT EXISTS``CREATE TYPE`empêche l'échec si le type existe déjà. (Facultatif)
+ `udt_name`est le nom complet de l'UDT au format type, par exemple. `my_keyspace.my_type` Si vous définissez le keyspace actuel avec l'`USE`instruction, il n'est pas nécessaire de spécifier le nom du keyspace.
+ `field_definition`se compose d'un nom et d'un type.

Le tableau suivant présente des exemples de noms UDT autorisés. La première colonne indique comment saisir le nom lorsque vous créez le type, la deuxième colonne montre comment Amazon Keyspaces met en forme le nom en interne. Amazon Keyspaces attend le nom formaté pour des opérations telles que. `GetType`


| Nom saisi | Nom formaté | Remarque | 
| --- | --- | --- | 
|  MY\$1UDT  | my\$1udt | Sans guillemets, Amazon Keyspaces convertit tous les caractères majuscules en minuscules. | 
|  "MY\$1UDT"  | MY\$1UDT | Avec les guillemets, Amazon Keyspaces respecte les majuscules et supprime les guillemets du nom formaté. | 
|  "1234"  | 1234 | Avec des guillemets, le nom peut commencer par un chiffre, et Amazon Keyspaces supprime les guillemets du nom formaté. | 
|  "Special\$1Ch@r@cters<>\$1\$1"  | Special\$1Ch@r@cters<>\$1\$1 | Avec des guillemets, le nom peut contenir des caractères spéciaux, et Amazon Keyspaces supprime les guillemets du nom formaté. | 
|  "nested""""""quotes"  | nested"""quotes | Amazon Keyspaces supprime les guillemets extérieurs et les guillemets d'échappement du nom formaté. | 

**Exemples**

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

Vous pouvez nicher UDTs si l'UDT imbriqué est gelé. Pour plus d'informations sur les valeurs par défaut et les quotas pour les types, consultez[Quotas UDT et valeurs par défaut d'Amazon Keyspaces](quotas.md#udt-table).

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

Pour d'autres exemples de code montrant comment créer UDTs, consultez[Types définis par l'utilisateur (UDTs) dans Amazon Keyspaces](udts.md).

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

Utilisez l'`DROP TYPE`instruction pour supprimer un UDT. Vous ne pouvez supprimer qu'un type qui n'est pas utilisé par un autre type ou une autre table.

 **Syntaxe**

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

Où :
+ `IF EXISTS``DROP TYPE`empêche l'échec si le type n'existe pas. (Facultatif)
+ `udt_name`est le nom complet de l'UDT au format type, par exemple. `my_keyspace.my_type` Si vous définissez le keyspace actuel avec l'`USE`instruction, il n'est pas nécessaire de spécifier le nom du keyspace.

**Exemple**

```
DROP TYPE udt_name;
```

# Instructions DML (langage de manipulation de données) dans Amazon Keyspaces
<a name="cql.dml"></a>

Le *langage de manipulation de données* (DML) est l'ensemble des instructions CQL (Cassandra Query Language) que vous utilisez pour gérer les données dans les tables Amazon Keyspaces (pour Apache Cassandra). Vous utilisez des instructions DML pour ajouter, modifier ou supprimer des données dans une table.

Vous utilisez également les instructions DML pour interroger les données d'une table. (Notez que CQL ne prend pas en charge les jointures ou les sous-requêtes.)

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

Utilisez une instruction SELECT pour interroger les données. 

**Syntaxe**

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

**Exemples**

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

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

Pour un tableau qui fait correspondre les types de données codés en JSON aux types de données Amazon Keyspaces, consultez. [Encodage JSON des types de données Amazon Keyspaces](cql.elements.md#cql.data-types.JSON)

**Utilisation du `IN` mot clé**

Le `IN` mot clé indique l'égalité pour une ou plusieurs valeurs. Il peut être appliqué à la clé de partition et à la colonne de clustering. Les résultats sont renvoyés dans l'ordre dans lequel les clés sont présentées dans le `SELECT` relevé.

**Exemples**

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

Pour plus d'informations sur le `IN` mot clé et sur la manière dont Amazon Keyspaces traite l'instruction, consultez. [Utiliser l'`IN`opérateur avec l'`SELECT`instruction dans une requête dans Amazon Keyspaces](in.select.md)

**Résultats de commande**

La `ORDER BY` clause indique l'ordre de tri des résultats renvoyés. Il prend comme arguments une liste de noms de colonnes ainsi que l'ordre de tri de chaque colonne. Vous pouvez uniquement spécifier des colonnes de clustering dans les clauses de commande. Les colonnes non groupées ne sont pas autorisées. Les options d'ordre de tri concernent `ASC` l'ordre de tri croissant et `DESC` décroissant. Si l'ordre de tri est omis, l'ordre par défaut de la colonne de clustering est utilisé. Pour les ordres de tri possibles, voir[Résultats des commandes avec `ORDER BY` Amazon Keyspaces](ordering-results.md).

**Exemple**

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

Lorsque vous utilisez `ORDER BY` le `IN` mot clé, les résultats sont classés dans une page. La réorganisation complète avec pagination désactivée n'est pas prise en charge.

**JETON**

Vous pouvez appliquer la `TOKEN` fonction à la `PARTITION KEY` colonne dans `SELECT` et `WHERE` aux clauses. Avec cette `TOKEN` fonction, Amazon Keyspaces renvoie des lignes en fonction de la valeur du jeton mappé `PARTITION_KEY` plutôt que de la valeur du. `PARTITION KEY`

`TOKEN`les relations ne sont pas prises en charge avec le `IN` mot clé.

**Exemples**

```
SELECT TOKEN(id) from my_table; 

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

**Fonction TTL**

Vous pouvez utiliser la `TTL` fonction avec l'`SELECT`instruction pour récupérer le délai d'expiration en secondes enregistré pour une colonne. Si aucune `TTL` valeur n'est définie, la fonction revient`null`.

**Exemple**

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

La `TTL` fonction ne peut pas être utilisée sur des colonnes à plusieurs cellules telles que des collections.

**WRITETIMEfonction**

Vous pouvez utiliser la `WRITETIME` fonction avec l'`SELECT`instruction pour récupérer l'horodatage stocké sous forme de métadonnées pour la valeur d'une colonne uniquement si la table utilise des horodatages côté client. Pour de plus amples informations, veuillez consulter [Horodatages côté client dans Amazon Keyspaces](client-side-timestamps.md). 

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

La `WRITETIME` fonction ne peut pas être utilisée sur des colonnes à plusieurs cellules telles que des collections.

**Note**  
Pour des raisons de compatibilité avec le comportement établi du pilote Cassandra, les politiques d'autorisation basées sur les balises ne sont pas appliquées lorsque vous effectuez des opérations sur les tables système à l'aide d'appels d'API Cassandra Query Language (CQL) via les pilotes Cassandra et les outils de développement. Pour de plus amples informations, veuillez consulter [Accès aux ressources Amazon Keyspaces basé sur des balises](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-tags).

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

Utilisez l'instruction `INSERT` pour ajouter une ligne à une table.

**Syntaxe**

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

**Exemple**

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

**Paramètres de mise à jour**

`INSERT`prend en charge les valeurs suivantes comme suit `update_parameter` :
+ `TTL`— Une valeur temporelle en secondes. La valeur maximale configurable est de 630 720 000 secondes, soit l'équivalent de 20 ans.
+ `TIMESTAMP`— Une `bigint` valeur représentant le nombre de microsecondes écoulées depuis l'heure de base standard connue sous le nom de epoch : 1er janvier 1970 à 00h00 GMT. Dans Amazon Keyspaces, un horodatage doit être compris entre 2 jours dans le passé et 5 minutes dans le futur.

**Exemple**

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

**Support JSON**

Pour un tableau qui fait correspondre les types de données codés en JSON aux types de données Amazon Keyspaces, consultez. [Encodage JSON des types de données Amazon Keyspaces](cql.elements.md#cql.data-types.JSON)

Vous pouvez utiliser le `JSON` mot clé pour insérer une carte `JSON` codée sous forme de ligne unique. Pour les colonnes qui existent dans le tableau mais qui sont omises dans l'instruction d'insertion JSON, utilisez `DEFAULT UNSET` pour conserver les valeurs existantes. `DEFAULT NULL`À utiliser pour écrire une valeur NULL dans chaque ligne de colonnes omises et remplacer les valeurs existantes (les frais d'écriture standard s'appliquent). `DEFAULT NULL`est l'option par défaut.

**Exemple**

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

Si les données JSON contiennent des clés dupliquées, Amazon Keyspaces stocke la dernière valeur de la clé (similaire à Apache Cassandra). Dans l'exemple suivant, où se trouve la clé dupliquée`id`, la valeur `234-56-7890` est utilisée.

**Exemple**

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

Utilisez l'instruction `UPDATE` pour modifier une ligne d'une table.

**Syntaxe**

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

**Exemple**

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

Pour incrémenter un `counter`, utilisez la syntaxe suivante. Pour de plus amples informations, veuillez consulter [Compteurs](cql.elements.md#cql.data-types.numeric.counters).

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

**Paramètres de mise à jour**

`UPDATE`prend en charge les valeurs suivantes comme suit `update_parameter` :
+ `TTL`— Une valeur temporelle en secondes. La valeur maximale configurable est de 630 720 000 secondes, soit l'équivalent de 20 ans.
+ `TIMESTAMP`— Une `bigint` valeur représentant le nombre de microsecondes écoulées depuis l'heure de base standard connue sous le nom de epoch : 1er janvier 1970 à 00h00 GMT. Dans Amazon Keyspaces, un horodatage doit être compris entre 2 jours dans le passé et 5 minutes dans le futur.

**Exemple**

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

Utilisez l'instruction `DELETE` pour supprimer une ligne d'une table.

**Syntaxe**

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

Où :
+ `table_name` est la table qui contient la ligne à supprimer.

**Exemple**

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

`DELETE`prend en charge la valeur suivante en tant que `update_parameter` :
+ `TIMESTAMP`— Une `bigint` valeur représentant le nombre de microsecondes écoulées depuis l'heure de base standard connue sous le nom de epoch : 1er janvier 1970 à 00h00 GMT.

# Fonctions intégrées dans Amazon Keyspaces
<a name="cql.functions"></a>

Amazon Keyspaces (pour Apache Cassandra) prend en charge diverses fonctions intégrées que vous pouvez utiliser dans les instructions CQL (Cassandra Query Language).

**Topics**
+ [Fonctions scalaires](#cql.functions.scalar)

## Fonctions scalaires
<a name="cql.functions.scalar"></a>

Une *fonction scalaire* effectue un calcul sur une valeur unique et renvoie le résultat sous forme de valeur unique. Amazon Keyspaces prend en charge les fonctions scalaires suivantes.


****  

| Fonction | Description | 
| --- | --- | 
|  `blobAsType`  | Renvoie une valeur du type de données spécifié. | 
|  `cast`  | Convertit un type de données natif en un autre type de données natif. | 
|  `currentDate`  | Renvoie le courant date/time sous forme de date. | 
|  `currentTime`  | Renvoie le courant date/time sous forme d'heure. | 
|  `currentTimestamp`  | Renvoie le courant date/time sous forme d'horodatage. | 
|  `currentTimeUUID`  | Renvoie le courant date/time sous la forme d'untimeuuid. | 
|  `fromJson`  | Convertit la chaîne JSON dans le type de données de la colonne sélectionnée.  | 
|  `maxTimeuuid`  | Renvoie la plus grande valeur possible timeuuid pour l'horodatage ou la chaîne de date.  | 
|  `minTimeuuid`  | Renvoie la valeur la plus petite possible timeuuid pour l'horodatage ou la chaîne de date.  | 
|  `now`  | Renvoie un nouveau timeuuid unique.  | 
|  `toDate`  | Convertit un timeuuid ou un horodatage en un type de date. | 
|  `toJson`  | Renvoie la valeur de colonne de la colonne sélectionnée au format JSON.  | 
|  `token`  | Renvoie la valeur de hachage de la clé de partition.  | 
|  `toTimestamp`  | Convertit un timeuuid ou une date en horodatage. | 
|  `TTL`  | Renvoie le délai d'expiration en secondes pour une colonne. | 
|  `typeAsBlob`  | Convertit le type de données spécifié enblob. | 
|  `toUnixTimestamp`  | Convertit un timeuuid ou un horodatage en bigInt. | 
|  `uuid`  | Renvoie un UUID de version 4 aléatoire.  | 
|  `writetime`  | Renvoie l'horodatage de la valeur de la colonne spécifiée. | 
|  `dateOf`  | (Obsolète) Extrait l'horodatage d'un timeuuid et renvoie la valeur sous forme de date. | 
|  `unixTimestampOf`  | (Obsolète) Extrait l'horodatage d'un timeuuid et renvoie la valeur sous la forme d'un horodatage entier brut 64 bits.  | 