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.

# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la gestion d’index
<a name="SQLtoNoSQL.Indexes"></a>

Les index donnent accès à d’autres modèles de requête et peuvent accélérer les requêtes. Cette section compare la création et l’utilisation des index dans SQL et Amazon DynamoDB.

Que vous utilisiez une base de données relationnelle ou DynamoDB, vous devez recourir à la création d’index judicieusement. Chaque fois qu’une écriture se produit sur une table, tous les index de la table doivent être mis à jour. Dans un environnement à forte densité d’écritures avec de grandes tables, cette opération peut consommer d’importantes quantité de ressources système. Dans un environnement en lecture seule ou principalement en lecture, ce risque est moins important. Cependant, vous devez vous assurer que les index sont effectivement utilisés par votre application et pas simplement qu’ils occupent de l’espace.

**Topics**
+ [

## Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la création d’un index
](#SQLtoNoSQL.Indexes.Creating)
+ [

## Différences entre une base de données relationnelle (SQL) et DynamoDB lors de l’interrogation et de l’analyse d’un index
](#SQLtoNoSQL.Indexes.QueryAndScan)

## Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la création d’un index
<a name="SQLtoNoSQL.Indexes.Creating"></a>

Comparez l’instruction `CREATE INDEX` dans SQL avec l’opération `UpdateTable` dans Amazon DynamoDB.

**Topics**
+ [

### Création d’un index avec SQL
](#SQLtoNoSQL.Indexes.Creating.SQL)
+ [

### Création d’un index dans DynamoDB
](#SQLtoNoSQL.Indexes.Creating.DynamoDB)

### Création d’un index avec SQL
<a name="SQLtoNoSQL.Indexes.Creating.SQL"></a>

Dans une base de données relationnelle, un index est une structure de données qui vous permet d’exécuter des requêtes rapides sur différentes colonnes d’une table. Vous pouvez utiliser l’instruction SQL `CREATE INDEX` pour ajouter un index à une table existante, en spécifiant les colonnes à indexer. Une fois que l’index a été créé, vous pouvez interroger les données de la table comme à l’habitude, mais maintenant la base de données peut utiliser l’index pour retrouver rapidement les lignes spécifiées dans le tableau au lieu d’analyser la totalité de la table.

Une fois que vous créez un index, la base de données le gère automatiquement. Chaque fois que vous modifiez les données de la table, l’index est automatiquement modifié pour refléter les modifications de la table.

Dans MySQL, il vous faudrait créer un index semblable au suivant.

```
CREATE INDEX GenreAndPriceIndex
ON Music (genre, price);
```

### Création d’un index dans DynamoDB
<a name="SQLtoNoSQL.Indexes.Creating.DynamoDB"></a>

Dans DynamoDB, vous pouvez créer et utiliser un *index secondaire* à des fins similaires.

Les index dans DynamoDB sont différents de leurs équivalents relationnels. Lorsque vous créez un index secondaire, vous devez spécifier ses attributs de clé, c’est-à-dire une clé de partition et une clé de tri. Après avoir créé l’index secondaire, vous pouvez effectuer une opération `Query` ou `Scan` sur celui-ci, comme vous le feriez avec une table. DynamoDB n’ayant pas d’optimiseur de requête, un index secondaire n’est utilisé que lorsque vous effectuez une opération `Query` ou `Scan` sur celui-ci.

DynamoDB prend en charge deux types d’index :
+ Index secondaires globaux – La clé primaire de l’index peut être constituée de deux attributs quelconques de sa table. 
+ Index secondaires locaux – La clé de partition de l’index doit être la même que la clé de partition de sa table. Cependant, la clé de tri peut être n’importe quel autre attribut.

DynamoDB veille à ce que les données dans un index secondaire soient éventuellement cohérentes avec sa table. Vous pouvez demander des opérations `Query` ou `Scan` fortement cohérentes sur une table ou un index secondaire local. Cependant, les index secondaires globaux ne prennent en charge que la cohérence éventuelle.

Vous pouvez ajouter un index secondaire global à une table existante à l’aide de l’opération `UpdateTable` et en spécifiant `GlobalSecondaryIndexUpdates`.

```
{
    TableName: "Music",
    AttributeDefinitions:[
        {AttributeName: "Genre", AttributeType: "S"},
        {AttributeName: "Price", AttributeType: "N"}
    ],
    GlobalSecondaryIndexUpdates: [
        {
            Create: {
                IndexName: "GenreAndPriceIndex",
                KeySchema: [
                    {AttributeName: "Genre", KeyType: "HASH"}, //Partition key
                    {AttributeName: "Price", KeyType: "RANGE"}, //Sort key
                ],
                Projection: {
                    "ProjectionType": "ALL"
                },
                ProvisionedThroughput: {                                // Only specified if using provisioned mode
                    "ReadCapacityUnits": 1,"WriteCapacityUnits": 1
                }
            }
        }
    ]
}
```

Vous devez fournir les paramètres suivants à `UpdateTable` :
+ `TableName` – Table à laquelle l’index sera associé.
+ `AttributeDefinitions` – Types de données pour les attributs de schéma de clé de l’index.
+ `GlobalSecondaryIndexUpdates` – Détails sur l’index que vous souhaitez créer :
  + `IndexName` – Nom pour l’index.
  + `KeySchema` – Attributs utilisés pour la clé primaire de l’index.
  + `Projection` – Attributs de la table qui sont copiés dans l’index. Dans ce cas, `ALL` signifie que tous les attributs sont copiés.
  + `ProvisionedThroughput (for provisioned tables)` – Nombre de lectures et d’écritures par seconde nécessaires pour ce index. (Cette information est distincte des paramètres de débit alloué de la table.) 

Une partie de cette opération implique le renvoi de données de la table vers le nouvel index. Pendant le renvoi, la table demeure disponible. Cependant, l’index n’est pas prêt jusqu’à ce que son attribut `Backfilling` passe de true à false. Vous pouvez utiliser l’opération `DescribeTable` pour afficher cet attribut.

## Différences entre une base de données relationnelle (SQL) et DynamoDB lors de l’interrogation et de l’analyse d’un index
<a name="SQLtoNoSQL.Indexes.QueryAndScan"></a>

Comparez l’interrogation et l’analyse d’un index à l’aide de l’instruction SELECT dans SQL avec les opérations `Query` et `Scan` dans Amazon DynamoDB.

**Topics**
+ [

### Interrogation et analyse d’un index avec SQL
](#SQLtoNoSQL.Indexes.QueryAndScan.SQL)
+ [

### Interrogation et analyse d’un index dans DynamoDB
](#SQLtoNoSQL.Indexes.QueryAndScan.DynamoDB)

### Interrogation et analyse d’un index avec SQL
<a name="SQLtoNoSQL.Indexes.QueryAndScan.SQL"></a>

Dans une base de données relationnelle, vous n’utilisez pas directement les index. Au lieu de cela, vous interrogez les tables à l’aide d’instructions `SELECT` et l’optimiseur de requête peut utiliser tous les index.

Un *optimiseur de requête* est un composant d’un système de gestion de base de données relationnelle (SGBDR) qui évalue les index disponibles et détermine s’ils peuvent être utilisés pour accélérer une requête. Si tel est le cas, le SGBDR accède d’abord à l’index, puis l’utilise pour rechercher les données dans la table.

Voici quelques instructions SQL qui peuvent être utilisées *GenreAndPriceIndex*pour améliorer les performances. Nous supposons que la table *Music* possède suffisamment de données pour que l’optimiseur de requête décide d’utiliser cet index, plutôt que de simplement analyser la totalité de la table.

```
/* All of the rock songs */

SELECT * FROM Music
WHERE Genre = 'Rock';
```

```
/* All of the cheap country songs */

SELECT Artist, SongTitle, Price FROM Music
WHERE Genre = 'Country' AND Price < 0.50;
```

### Interrogation et analyse d’un index dans DynamoDB
<a name="SQLtoNoSQL.Indexes.QueryAndScan.DynamoDB"></a>

Dans DynamoDB, vous effectuez les opérations `Query` et `Scan` directement sur l’index, de la même manière que vous le feriez sur une table. Vous pouvez interroger ou analyser l’index à l’aide de l’API DynamoDB ou de [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (langage de requête compatible SQL). Vous devez spécifier à la fois `TableName` et `IndexName`.

Voici quelques requêtes effectuées *GenreAndPriceIndex*dans DynamoDB. (Le schéma de clé de l’index est composé de *Genre* et de *Price*.)

------
#### [ DynamoDB API ]

```
// All of the rock songs

{
    TableName: "Music",
    IndexName: "GenreAndPriceIndex",
    KeyConditionExpression: "Genre = :genre",
    ExpressionAttributeValues: {
        ":genre": "Rock"
    },
};
```

Cet exemple utilise une `ProjectionExpression` pour indiquer que vous souhaitez que certains attributs seulement, et non leur totalité, apparaissent dans les résultats.

```
// All of the cheap country songs

{
    TableName: "Music",
    IndexName: "GenreAndPriceIndex",
    KeyConditionExpression: "Genre = :genre and Price < :price",
    ExpressionAttributeValues: {
        ":genre": "Country",
        ":price": 0.50
    },
    ProjectionExpression: "Artist, SongTitle, Price"
};
```

Ce qui suit est un scan en cours *GenreAndPriceIndex*.

```
// Return all of the data in the index

{
    TableName:  "Music",
    IndexName: "GenreAndPriceIndex"
}
```

------
#### [ PartiQL for DynamoDB ]

Avec PartiQL, vous utilisez l’instruction PartiQL `Select` pour interroger et analyser l’index.

```
// All of the rock songs

SELECT * 
FROM Music.GenreAndPriceIndex
WHERE Genre = 'Rock'
```

```
// All of the cheap country songs

SELECT * 
FROM Music.GenreAndPriceIndex
WHERE Genre = 'Rock' AND Price < 0.50
```

Ce qui suit est un scan en cours *GenreAndPriceIndex*.

```
// Return all of the data in the index

SELECT *
FROM Music.GenreAndPriceIndex
```

**Note**  
Pour obtenir des exemples de code utilisant `Select`, consultez [Instructions PartiQL de sélection pour DynamoDB](ql-reference.select.md).

------