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 lecture de données à partir d’une table
<a name="SQLtoNoSQL.ReadData"></a>

Avec SQL, vous utilisez l’instruction `SELECT` pour extraire une ou plusieurs lignes d’une table. Vous utilisez la clause `WHERE` pour déterminer les données qui vous sont renvoyées.

Cela est différent d’Amazon DynamoDB, qui propose les opérations suivantes pour la lecture de données :
+ `ExecuteStatement` récupère un ou plusieurs éléments d’une table. `BatchExecuteStatement` récupère plusieurs éléments de tables différentes en une seule opération. Ces deux opérations utilisent [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un langage de requête compatible SQL.
+ `GetItem` – Extrait un élément unique d’une table. C’est le moyen le plus efficace de lire un élément unique, car il fournit un accès direct à l’emplacement physique de l’élément. (DynamoDB fournit également l’opération `BatchGetItem` permettant d’effectuer jusqu’à 100 appels `GetItem` en une seule opération.)
+ `Query` – Extrait tous les éléments ayant une clé de partition spécifique. Au sein de ces éléments, vous pouvez appliquer une condition à la clé de tri et récupérer uniquement un sous-ensemble des données. `Query` fournit un accès rapide et efficace aux partitions où les données sont stockées. (Pour plus d’informations, consultez [Partitions et distribution des données dans DynamoDB](HowItWorks.Partitions.md).)
+ `Scan` – Extrait tous les éléments de la table spécifiée. (Cette opération ne doit pas être utilisée avec les grandes tables, car elle peut consommer d’importantes quantités de ressources système.)

**Note**  
Avec une base de données relationnelle, vous pouvez utiliser l’instruction `SELECT` pour joindre les données de plusieurs tables et retourner les résultats. Les jointures sont fondamentales pour le modèle relationnel. Pour garantir l’efficacité des jointures, les performances de la base de données et de ses applications doivent être ajustées en permanence. DynamoDB est une base de données NoSQL non relationnelle qui ne prend pas en charge les jointures de tables. Au lieu de cela, les applications lisent les données d’une seule table à la fois. 

Les sections suivantes décrivent les différents cas d’utilisation de lecture des données et comment exécuter ces tâches avec une base de données relationnelle et avec DynamoDB.

**Topics**
+ [

# Différences dans la lecture d’un élément à l’aide de sa clé primaire
](SQLtoNoSQL.ReadData.SingleItem.md)
+ [

# Différences dans l’interrogation d’une table
](SQLtoNoSQL.ReadData.Query.md)
+ [

# Différences dans l’analyse d’une table
](SQLtoNoSQL.ReadData.Scan.md)

# Différences dans la lecture d’un élément à l’aide de sa clé primaire
<a name="SQLtoNoSQL.ReadData.SingleItem"></a>

Un modèle d’accès commun aux bases de données consiste à lire un seul élément d’une table. Vous devez spécifier la clé primaire de l’élément que vous voulez.

**Topics**
+ [

## Lecture d’un élément à partir de sa clé primaire avec SQL
](#SQLtoNoSQL.ReadData.SingleItem.SQL)
+ [

## Lecture d’un élément à partir de sa clé primaire dans DynamoDB
](#SQLtoNoSQL.ReadData.SingleItem.DynamoDB)

## Lecture d’un élément à partir de sa clé primaire avec SQL
<a name="SQLtoNoSQL.ReadData.SingleItem.SQL"></a>

En SQL, l’extraction de données d’une table s’effectue à l’aide de l’instruction `SELECT`. Vous pouvez demander une ou plusieurs colonnes du résultat (ou la totalité, si vous utilisez l’opération `*`). La clause `WHERE` détermine les lignes à retourner.

L’instruction `SELECT` suivante permet d’extraire une seule ligne de la table *Music*. La clause `WHERE` spécifie les valeurs de clé primaire.

```
SELECT *
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```

Vous pouvez modifier cette requête pour récupérer uniquement un sous-ensemble des colonnes.

```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```

Notez que la clé primaire de ce tableau est composée de *Artist* et *SongTitle*.

## Lecture d’un élément à partir de sa clé primaire dans DynamoDB
<a name="SQLtoNoSQL.ReadData.SingleItem.DynamoDB"></a>

Dans Amazon DynamoDB, vous pouvez lire un élément à partir d’une table à 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).

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

Avec l’API DynamoDB, vous utilisez l’opération `PutItem` pour ajouter un élément à une table.

DynamoDB propose l’opération `GetItem` pour extraire un élément à partir de sa clé primaire. L’opération `GetItem` est très efficace, car elle donne directement accès à l’emplacement physique de l’élément. (Pour plus d’informations, consultez [Partitions et distribution des données dans DynamoDB](HowItWorks.Partitions.md).)

Par défaut, `GetItem` retourne l’élément entier avec tous ses attributs.

```
{
    TableName: "Music",
    Key: {
        "Artist": "No One You Know",
        "SongTitle": "Call Me Today"
    }
}
```

Vous pouvez ajouter un paramètre `ProjectionExpression` pour renvoyer uniquement certains des attributs.

```
{
    TableName: "Music",
    Key: {
        "Artist": "No One You Know",
        "SongTitle": "Call Me Today"
    },
    "ProjectionExpression": "AlbumTitle, Year, Price"
}
```

Notez que la clé primaire de ce tableau est composée de *Artist* et *SongTitle*.

L’opération `GetItem` de DynamoDB est très efficace. Elle utilise les valeurs de clé primaire pour déterminer l’emplacement exact de stockage de l’élément en question et le récupère directement de cet emplacement. L’instruction SQL `SELECT` est efficace de la même façon, en ce qui concerne la récupération d’éléments par valeurs de clé primaire.

L’instruction SQL `SELECT` prend en charge de nombreux types de requêtes et d’analyses de table. DynamoDB propose une fonctionnalité similaire avec ses opérations `Query` et `Scan`, qui sont décrites dans [Différences dans l’interrogation d’une table](SQLtoNoSQL.ReadData.Query.md) et [Différences dans l’analyse d’une table](SQLtoNoSQL.ReadData.Scan.md).

L’instruction SQL `SELECT` permet d’effectuer des jointures de tables, ce qui vous permet de récupérer les données de plusieurs tables à la fois. Les jointures sont plus efficaces lorsque les tables de base de données sont normalisées et que les relations entre les tables sont claires. Toutefois, si vous joignez un trop grand nombre de tables dans une instruction `SELECT`, les performances de l’application peuvent en être affectées. Vous pouvez contourner ces problèmes en utilisant la réplication de base de données, les vues matérialisées ou les réécritures de requête.

DynamoDB est une base de données non relationnelle ne prenant pas en charge les jointures de tables. Si vous migrez une application existante à partir d’une base de données relationnelle vers DynamoDB, vous devez dénormaliser votre modèle de données pour éliminer la nécessité de jointures.

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

Avec PartiQL, vous utilisez l’opération `ExecuteStatement` pour lire un élément d’une table, à l’aide de l’instruction PartiQL `Select`.

```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```

Notez que la clé primaire de ce tableau est composée de Artist et SongTitle. 

**Note**  
 L’instruction PartiQL select permet également d’interroger ou d’analyser une table DynamoDB

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

------

# Différences dans l’interrogation d’une table
<a name="SQLtoNoSQL.ReadData.Query"></a>

Un autre modèle commun d’accès est la lecture de plusieurs éléments d’une table, selon les critères de votre requête.

**Topics**
+ [

## Interrogation d’une table avec SQL
](#SQLtoNoSQL.ReadData.Query.SQL)
+ [

## Interrogation d’une table dans DynamoDB
](#SQLtoNoSQL.ReadData.Query.DynamoDB)

## Interrogation d’une table avec SQL
<a name="SQLtoNoSQL.ReadData.Query.SQL"></a>

Lorsque vous utilisez SQL, l’instruction `SELECT` vous permet d’interroger les colonnes clé, les colonnes non-clé ou toute autre combinaison. La clause `WHERE` détermine quelles lignes sont retournées, comme illustré dans les exemples suivants.

```
/* Return a single song, by primary key */

SELECT * FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today';
```

```
/* Return all of the songs by an artist */

SELECT * FROM Music
WHERE Artist='No One You Know';
```

```
/* Return all of the songs by an artist, matching first part of title */

SELECT * FROM Music
WHERE Artist='No One You Know' AND SongTitle LIKE 'Call%';
```

```
/* Return all of the songs by an artist, only if the price is less than 1.00 */

SELECT * FROM Music
WHERE Artist='No One You Know'
AND Price < 1.00;
```

Notez que la clé primaire de ce tableau est composée de *Artist* et *SongTitle*.

## Interrogation d’une table dans DynamoDB
<a name="SQLtoNoSQL.ReadData.Query.DynamoDB"></a>

Dans Amazon DynamoDB, vous pouvez interroger un élément à partir d’une table à 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).

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

Avec Amazon DynamoDB, vous pouvez utiliser l’opération `Query` pour extraire des données de façon similaire. L’opération `Query` fournit un accès rapide et efficace aux emplacements physiques où sont stockées les données. Pour de plus amples informations, veuillez consulter [Partitions et distribution des données dans DynamoDB](HowItWorks.Partitions.md).

Vous pouvez utiliser `Query` avec n’importe quel(le) table ou index secondaire. Vous devez spécifier une condition d’égalité pour la valeur de la clé de partition et, le cas échéant, fournir une autre condition pour l’attribut de la clé de tri s’il est défini.

Le paramètre `KeyConditionExpression` spécifie les valeurs clés que vous souhaitez interroger. Vous pouvez utiliser un paramètre `FilterExpression` facultatif pour supprimer des résultats certains éléments avant qu’ils ne vous soient retournés.

Dans DynamoDB, vous devez utiliser des `ExpressionAttributeValues` comme espaces réservés dans des paramètres d’expression (tels que `KeyConditionExpression` et `FilterExpression`). C’est analogue à l’utilisation des *variables de liaison* des bases de données relationnelles, où vous remplacez les valeurs réelles dans l’instruction `SELECT` au moment de l’exécution.

Notez que la clé primaire de ce tableau est composée de *Artist* et *SongTitle*.

Voici quelques exemples d’actions `Query` de DynamoDB.

```
// Return a single song, by primary key

{
    TableName: "Music",
    KeyConditionExpression: "Artist = :a and SongTitle = :t",
    ExpressionAttributeValues: {
        ":a": "No One You Know",
        ":t": "Call Me Today"
    }
}
```

```
// Return all of the songs by an artist

{
    TableName: "Music",
    KeyConditionExpression: "Artist = :a",
    ExpressionAttributeValues: {
        ":a": "No One You Know"
    }
}
```

```
// Return all of the songs by an artist, matching first part of title

{
    TableName: "Music",
    KeyConditionExpression: "Artist = :a and begins_with(SongTitle, :t)",
    ExpressionAttributeValues: {
        ":a": "No One You Know",
        ":t": "Call"
    }
}
```

```
// Return all of the songs by an artist, only if the price is less than 1.00

{
    TableName: "Music",
    KeyConditionExpression: "Artist = :a",
    FilterExpression: "Price < :p",
    ExpressionAttributeValues: {
        ":a": "No One You Know",
        ":p": 1.00
    }
}
```

**Note**  
A `FilterExpression` est appliqué après les `Query` lectures des éléments correspondants, il ne réduit donc pas la capacité de lecture consommée. Dans la mesure du possible, modélisez vos données de manière à ce que les conditions de plage `KeyConditionExpression` soient utilisées sur la clé de tri pour des requêtes efficaces. Pour de plus amples informations, veuillez consulter [Interrogation de tables dans DynamoDB](Query.md).

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

Avec PartiQL, vous pouvez exécuter une requête en utilisant l’opération `ExecuteStatement` et l’instruction `Select` sur la clé de partition.

```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know'
```

Une telle utilisation de l’instruction `SELECT` renvoie tous les morceaux associés à cet `Artist` spécifique.

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

------

# Différences dans l’analyse d’une table
<a name="SQLtoNoSQL.ReadData.Scan"></a>

Dans SQL, une instruction `SELECT` sans une clause `WHERE` retourne chaque ligne d’une table. Dans Amazon DynamoDB, l’opération `Scan` effectue la même chose. Dans les deux cas, vous pouvez extraire tous les éléments, ou seulement certains d’entre eux.

Que vous utilisiez une base de données SQL ou NoSQL, les analyses doivent être utilisées avec modération, car elles peuvent consommer d’importantes quantités de ressources système. Parfois, une analyse est appropriée (analyse d’une petite table, par exemple) ou inévitable (exportation en bloc de données, par exemple). Cependant, en règle générale, vous devez concevoir vos applications de façon à éviter d’exécuter des analyses. Pour de plus amples informations, veuillez consulter [Interrogation de tables dans DynamoDB](Query.md).

**Note**  
L’exportation en masse crée également au moins un fichier par partition. Tous les éléments de chaque fichier proviennent de l’espace de clés haché de cette partition particulière.

**Topics**
+ [

## Analyse d’une table avec SQL
](#SQLtoNoSQL.ReadData.Scan.SQL)
+ [

## Analyse d’une table dans DynamoDB
](#SQLtoNoSQL.ReadData.Scan.DynamoDB)

## Analyse d’une table avec SQL
<a name="SQLtoNoSQL.ReadData.Scan.SQL"></a>

Lorsque vous utilisez SQL, vous pouvez analyser une table et en extraire toutes les données en utilisant une instruction `SELECT` sans spécifier de clause `WHERE`. Vous pouvez demander une ou plusieurs colonnes dans le résultat. Ou, vous pouvez demander leur totalité si vous utilisez le caractère générique (\$1).

Voici des exemples d’utilisation d’une déclaration `SELECT`.

```
/* Return all of the data in the table */
SELECT * FROM Music;
```

```
/* Return all of the values for Artist and Title */
SELECT Artist, Title FROM Music;
```

## Analyse d’une table dans DynamoDB
<a name="SQLtoNoSQL.ReadData.Scan.DynamoDB"></a>

Dans Amazon DynamoDB, vous pouvez analyser une table à 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).

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

Grâce à l’API DynamoDB, vous utilisez l’opération `Scan` pour renvoyer un ou plusieurs éléments et attributs d’élément en accédant à chaque élément dans une table ou un index secondaire.

```
// Return all of the data in the table
{
    TableName:  "Music"
}
```

```
// Return all of the values for Artist and Title
{
    TableName:  "Music",
    ProjectionExpression: "Artist, Title"
}
```

L’opération `Scan` propose également un paramètre `FilterExpression` qui permet d’écarter les éléments qui ne doivent pas figurer dans les résultats. Une `FilterExpression` est appliquée une fois l’analyse terminée, avant que les résultats vous soient renvoyés. Cela n’est pas recommandé avec des tables volumineuses, car vous continuez d’être facturé pour l’opération `Scan` complète, même si seuls quelques éléments correspondants sont renvoyés.

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

Avec PartiQL, vous procédez à une analyse à l’aide de l’opération `ExecuteStatement`, qui permet de renvoyer l’ensemble du contenu d’une table utilisant l’instruction `Select`.

```
SELECT AlbumTitle, Year, Price
FROM Music
```

Notez que cette instruction renvoie tous les éléments de la table Music. 

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

------