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.
# Découvrez comment passer de SQL à NoSQL
Si vous êtes développeur d’applications, il se peut que vous ayez une certaine expérience concernant l’utilisation d’un système de gestion de base de données relationnelle (SGBDR) et d’un langage de recherche structurée (SQL). Lorsque vous commencerez à utiliser le service Amazon DynamoDB, vous constaterez qu’il présente bon nombre de similitudes mais aussi de différences par rapport à SQL. *NoSQL* est un terme utilisé pour décrire les systèmes de base de données non relationnelle qui sont hautement disponibles, évolutifs et optimisés pour des performances élevées. Au lieu du modèle relationnel, les bases de données NoSQL (comme DynamoDB) utilisent d’autres modèles pour la gestion des données, tels que les paires clé-valeur ou le stockage de documents. Pour plus d’informations, veuillez consulter [Présentation de NoSQL](https://aws.amazon.com/nosql).
Amazon DynamoDB prend en charge [PartiQL](https://partiql.org/), un langage de requête open source compatible SQL qui vous permet d’interroger les données facilement et de manière efficace, quel que soit leur emplacement ou format de stockage. Avec PartiQL, vous pouvez facilement traiter des données structurées à partir de bases de données relationnelles, des données semi-structurées et imbriquées dans des formats de données ouvertes, et même des données sans schéma dans NoSQL ou des bases de données document qui autorisent différents attributs pour différentes lignes. Pour plus d’informations, consultez [Langage de requête PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html).
Les sections suivantes décrivent les tâches courantes de base de données, en comparant les instructions SQL et leurs opérations DynamoDB équivalentes.
**Note**
Les exemples SQL de cette section sont compatibles avec le SGBDR MySQL.
Les exemples DynamoDB dans cette section affichent le nom de l’opération DynamoDB, ainsi que ses paramètres au format JSON.
**Topics**
+ [
# Choix entre système relationnel (SQL) et NoSQL
](SQLtoNoSQL.WhyDynamoDB.md)
+ [
# Différences entre l’accès à une base de données relationnelle (SQL) et à DynamoDB
](SQLtoNoSQL.Accessing.md)
+ [
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la création d’une table
](SQLtoNoSQL.CreateTable.md)
+ [
# Différences entre l’obtention d’informations sur une table à partir d’une base de données relationnelle (SQL) et de DynamoDB
](SQLtoNoSQL.GetTableInfo.md)
+ [
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de l’écriture de données dans une table
](SQLtoNoSQL.WriteData.md)
+ [
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la lecture de données à partir d’une table
](SQLtoNoSQL.ReadData.md)
+ [
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la gestion d’index
](SQLtoNoSQL.Indexes.md)
+ [
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la modification de données dans une table
](SQLtoNoSQL.UpdateData.md)
+ [
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la suppression de données dans une table
](SQLtoNoSQL.DeleteData.md)
+ [
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la suppression d’une table
](SQLtoNoSQL.RemoveTable.md)
# Choix entre système relationnel (SQL) et NoSQL
Aujourd’hui, les applications ont des besoins plus exigeants que par le passé. Par exemple, un jeu en ligne peut démarrer avec quelques utilisateurs seulement et une très petite quantité de données. Cependant, si le jeu devient un succès, il peut facilement dépasser les ressources du système de gestion de la base de données sous-jacente. Il est fréquent que les applications web aient des centaines, des milliers ou des millions d’utilisateurs simultanés, avec des téraoctets ou plus de nouvelles données générées par jour. Les bases de données de telles applications doivent gérer des dizaines (voire des centaines) de milliers de lectures et d’écritures par seconde.
Amazon DynamoDB convient parfaitement à ces types de charges de travail. En tant que développeur, vous pouvez commencer à petite échelle et augmenter progressivement votre utilisation au fur et à mesure que votre application gagne en popularité. DynamoDB se met à l’échelle en toute transparence pour gérer un très grand nombre d’utilisateurs et des quantités considérables de données.
Pour en savoir plus sur la modélisation des bases de données relationnelles traditionnelles et sur la façon de l’adapter à DynamoDB, consultez [Bonnes pratiques de modélisation des données relationnelles dans DynamoDB](bp-relational-modeling.md).
Le tableau suivant présente quelques différences générales entre un système de gestion de base de données relationnelle (SGBDR) et DynamoDB.
****
| Caractéristiques | Système de gestion de base de données relationnelle (SGBDR) | Amazon DynamoDB |
| --- | --- | --- |
| Charges de travail optimales | Requêtes ad hoc ; entreposage de données ; traitement analytique en ligne (OLAP). | Applications web, y compris les réseaux sociaux, les jeux, le partage des fichiers multimédia et l’Internet des objets (IoT). |
| Modèle de données | Le modèle relationnel nécessite un schéma bien défini, dans lequel les données sont normalisées en tables, lignes et colonnes. De plus, toutes les relations sont définies entre tables, colonnes, index et autres éléments de base de données. | DynamoDB est sans schéma. Chaque table doit avoir une clé primaire pour identifier de façon unique chaque élément de données, mais aucune contrainte similaire ne s’applique aux attributs autres que de clé. DynamoDB peut gérer des données structurées ou semi-structurées, y compris des documents JSON. |
| Accès aux données | SQL constitue la norme pour le stockage et la récupération de données. Les bases de données relationnelles offrent un riche ensemble d’outils pour simplifier le développement d’applications de base de données, mais tous ces outils utilisent SQL. | Vous pouvez utiliser le AWS Management Console AWS CLI, le ou NoSQL WorkBench pour travailler avec DynamoDB et effectuer des tâches ad hoc. [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un langage de requête compatible SQL, vous permet de sélectionner, d’insérer, de mettre à jour et de supprimer des données dans DynamoDB. Les applications peuvent utiliser les kits de développement AWS logiciel (SDKs) pour travailler avec DynamoDB à l'aide d'interfaces basées sur des objets, centrées sur le document ou de bas niveau. |
| Performances | Les bases de données relationnelles étant optimisées pour le stockage, les performances dépendent généralement du sous-système du disque. Les développeurs et les administrateurs de base de données doivent optimiser les requêtes, les index et les structures de table afin d’atteindre des performances de pointe. | DynamoDB étant optimisé pour le calcul, les performances dépendent principalement du matériel sous-jacent et de la latence réseau. En tant que service géré, DynamoDB vous dispense, ainsi que vos applications, de ces détails d’implémentation, si bien que vous pouvez vous concentrer sur la conception et la génération d’applications robustes hautement performantes. |
| Dimensionnement | Il est plus facile d’agrandir avec un matériel plus rapide. Il est également possible pour les tables de base de données de s’étendre sur plusieurs hôtes d’un système distribué, mais cela nécessite des investissements supplémentaires. Les bases de données relationnelles possèdent une taille maximale pour le nombre de fichiers et leur taille, ce qui impose des limites supérieures sur l’évolutivité. | DynamoDB est conçu pour monter en charge à l’aide de clusters distribués de matériel. Cette conception permet un débit accru sans augmentation de la latence. Les clients spécifient leurs exigences de débit et DynamoDB alloue des ressources suffisantes pour répondre à ces exigences. Il n’y a aucune limite supérieure sur le nombre d’éléments par table, ni sur la taille totale de la table. |
# Différences entre l’accès à une base de données relationnelle (SQL) et à DynamoDB
Avant que votre application puise accéder à une base de données, elle doit être *authentifiée* pour garantir que l’application est autorisée à utiliser la base de données. Elle doit être *autorisée* de manière à ce que l’application ne puisse effectuer que les actions pour lesquelles elle possède des autorisations.
Le schéma suivant illustre l’interaction d’un client avec une base de données relationnelle et avec Amazon DynamoDB.
![\[Interaction avec les bases de données relationnelles et NoSQL\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/images/SQLtoNoSQL.png)
Le tableau suivant propose plus d’informations sur les tâches liées à l’interaction client.
****
| Caractéristiques | Système de gestion de base de données relationnelle (SGBDR) | Amazon DynamoDB |
| --- | --- | --- |
| Outils pour accéder à la base de données | La plupart des bases de données relationnelles offrent une interface de ligne de commande (CLI), de telle sorte que vous pouvez saisir des instructions SQL ad hoc et observer les résultats immédiatement. | Dans la plupart des cas, vous écrivez le code de l’application. Vous pouvez également utiliser le Workbench AWS Management Console, the AWS Command Line Interface (AWS CLI) ou NoSQL pour envoyer des requêtes ad hoc à DynamoDB et afficher les résultats. [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un langage de requête compatible SQL, vous permet de sélectionner, d’insérer, de mettre à jour et de supprimer des données dans DynamoDB. |
| Connexion à la base de données | Un programme d’application établit et gère une connexion réseau avec la base de données. Lorsque l’application est terminée, il met fin à la connexion. | DynamoDB est un service web, et les interactions avec celui-ci sont sans état. Les applications n’ont pas besoin de maintenir des connexions réseau permanentes. Au lieu de cela, l’interaction avec DynamoDB se produit via des requêtes et réponses HTTP(S). |
| Authentification | Une application ne peut pas se connecter à la base de données tant qu’elle n’est pas authentifiée. Le SGBDR peut effectuer l’authentification lui-même ou déléguer cette tâche au système d’exploitation hôte ou à un service d’annuaire. | Chaque demande adressée à DynamoDB doit être accompagnée d’une signature de chiffrement qui authentifie cette demande particulière. Ils AWS SDKs fournissent toute la logique nécessaire pour créer des signatures et des demandes de signature. Pour plus d'informations, consultez [la section Signature des demandes d' AWS API](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) dans le Références générales AWS. |
| Autorisation | Les applications ne peuvent exécuter que les actions pour lesquelles elles sont autorisées. Les administrateurs de base de données ou les propriétaires d’applications peuvent utiliser les instructions SQL GRANT et REVOKE pour contrôler l’accès aux objets de base de données (tels que les tables) et aux données (telles que les lignes d’une table), ou la possibilité d’émettre certaines instructions SQL. | Dans DynamoDB, l'autorisation est gérée Gestion des identités et des accès AWS par (IAM). Vous pouvez écrire une politique IAM pour accorder des autorisations sur une ressource DynamoDB (telle une table), puis autoriser des utilisateurs et des rôles à utiliser cette politique. IAM offre également un contrôle précis des accès pour les éléments de données individuels dans les tables DynamoDB. Pour de plus amples informations, veuillez consulter [Gestion des identités et des accès pour Amazon DynamoDB](security-iam.md). |
| Envoi d’une demande | L’application émet une instruction SQL pour chaque opération de base de données qu’elle souhaite effectuer. À la réception de l’instruction SQL, le SGBDR vérifie sa syntaxe, crée un plan pour effectuer l’opération, puis exécute le plan. | L’application envoie des requêtes HTTP(S) à DynamoDB. Une requête contient le nom de l’opération DynamoDB à effectuer, ainsi que les paramètres de celle-ci. DynamoDB exécute la requête immédiatement. |
| Réception d’une réponse | Le SGBDR retourne les résultats de l’instruction SQL. S’il y a une erreur, le SGBDR retourne un statut d’erreur et un message. | DynamoDB renvoie une réponse HTTP(S) contenant les résultats de l’opération. En cas d’erreur, DynamoDB renvoie un état et des messages d’erreur HTTP. |
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la création d’une table
Les tables sont les structures de données fondamentales dans les bases de données relationnelles et dans Amazon DynamoDB. Un système de gestion de base de données relationnelles (SGBDR) vous permet de définir le schéma de la table lorsque vous la créez. En revanche, les tables DynamoDB sont sans schéma. Lorsque vous créez une table, en dehors de la clé primaire, vous n’avez pas besoin de définir d’attributs ou de types de données supplémentaires.
La section suivante compare la méthode de création d’une table avec SQL d’une part et avec DynamoDB d’autre part.
**Topics**
+ [
## Création d’une table avec SQL
](#SQLtoNoSQL.CreateTable.SQL)
+ [
## Création d’une table avec DynamoDB
](#SQLtoNoSQL.CreateTable.DynamoDB)
## Création d’une table avec SQL
Avec SQL, la création d’une table s’effectue via l’instruction `CREATE TABLE`, comme le montre l’exemple suivant.
```
CREATE TABLE Music (
Artist VARCHAR(20) NOT NULL,
SongTitle VARCHAR(30) NOT NULL,
AlbumTitle VARCHAR(25),
Year INT,
Price FLOAT,
Genre VARCHAR(10),
Tags TEXT,
PRIMARY KEY(Artist, SongTitle)
);
```
La clé primaire de cette table comprend *Artist* et *SongTitle*.
Vous devez définir toutes les colonnes de la table et leurs types de données, ainsi que la clé primaire de la table. (Vous pouvez utiliser l’instruction `ALTER TABLE` pour modifier ces définitions ultérieurement, si nécessaire.)
De nombreuses implémentations SQL vous permettent de définir les spécifications de stockage de votre table, dans le cadre de l’instruction `CREATE TABLE`. Sauf spécification contraire, la table est créée avec les paramètres de stockage par défaut. Dans un environnement de production, un administrateur de base de données peut aider à déterminer les paramètres de stockage optimaux.
## Création d’une table avec DynamoDB
Utilisez l’opération `CreateTable` pour créer une table en mode alloué, en spécifiant les paramètres comme suit :
```
{
TableName : "Music",
KeySchema: [
{
AttributeName: "Artist",
KeyType: "HASH" //Partition key
},
{
AttributeName: "SongTitle",
KeyType: "RANGE" //Sort key
}
],
AttributeDefinitions: [
{
AttributeName: "Artist",
AttributeType: "S"
},
{
AttributeName: "SongTitle",
AttributeType: "S"
}
],
ProvisionedThroughput: { // Only specified if using provisioned mode
ReadCapacityUnits: 1,
WriteCapacityUnits: 1
}
}
```
La clé primaire de cette table est composée de *Artist* (clé de partition) et *SongTitle*(clé de tri).
Vous devez fournir les paramètres suivants à `CreateTable` :
+ `TableName` – Nom de la table.
+ `KeySchema` – Attributs utilisés pour la clé primaire. Pour plus d’informations, consultez [Tables, éléments et attributs](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.TablesItemsAttributes) et [Clé primaire](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.PrimaryKey).
+ `AttributeDefinitions` – Types de données pour les attributs du schéma de clé.
+ `ProvisionedThroughput (for provisioned tables)` – Nombre de lectures et d’écritures par seconde nécessaires pour cette table. DynamoDB réserve suffisamment de ressources de stockage et système pour que vos besoins de débit soient toujours satisfaits. Vous pouvez utiliser l’opération `UpdateTable` pour modifier ces éléments ultérieurement, si nécessaire. Vous n’avez pas besoin de spécifier les besoins de stockage d’une table, car DynamoDB gère entièrement l’allocation du stockage.
# Différences entre l’obtention d’informations sur une table à partir d’une base de données relationnelle (SQL) et de DynamoDB
Vous pouvez vérifier qu’une table a été créée selon vos spécifications. Dans une base de données relationnelle, la totalité du schéma de la table est affiché. Les tables Amazon DynamoDB étant sans schéma, seuls les attributs de clé primaire sont affichés.
**Topics**
+ [
## Obtention d’informations sur une table avec SQL
](#SQLtoNoSQL.GetTableInfo.SQL)
+ [
## Obtention d’informations sur une table dans DynamoDB
](#SQLtoNoSQL.GetTableInfo.DynamoDB)
## Obtention d’informations sur une table avec SQL
La plupart des systèmes de gestion de base de données relationnelle (SGBDR) permettent de décrire la structure d’une table : colonnes, types de données, définition de clé primaire, etc. Il n’existe aucune méthode standard pour ce faire dans SQL. Cependant, beaucoup de systèmes de base de données offrent une commande `DESCRIBE`. Voici un exemple de fichier de MySQL :
```
DESCRIBE Music;
```
Cette commande renvoie la structure de votre table, avec l’ensemble des noms de colonnes, types de données et tailles.
```
+------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+------------+-------------+------+-----+---------+-------+
| Artist | varchar(20) | NO | PRI | NULL | |
| SongTitle | varchar(30) | NO | PRI | NULL | |
| AlbumTitle | varchar(25) | YES | | NULL | |
| Year | int(11) | YES | | NULL | |
| Price | float | YES | | NULL | |
| Genre | varchar(10) | YES | | NULL | |
| Tags | text | YES | | NULL | |
+------------+-------------+------+-----+---------+-------+
```
La clé primaire de cette table comprend *Artist* et *SongTitle*.
## Obtention d’informations sur une table dans DynamoDB
DynamoDB intègre une opération `DescribeTable`, qui est similaire. Le seul paramètre requis est le nom de la table.
```
{
TableName : "Music"
}
```
La réponse de `DescribeTable` se présente ainsi :
```
{
"Table": {
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"TableName": "Music",
"KeySchema": [
{
"AttributeName": "Artist",
"KeyType": "HASH" //Partition key
},
{
"AttributeName": "SongTitle",
"KeyType": "RANGE" //Sort key
}
],
...
```
`DescribeTable` renvoie également des informations sur les index de la table, les paramètres de débit alloué, le nombre approximatif d’éléments et d’autres métadonnées.
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de l’écriture de données dans une table
Les tables des bases de données relationnelles contiennent des *lignes* de données. Les lignes sont composées de *colonnes*. Les tables Amazon DynamoDB contiennent des *éléments*. Les éléments sont composés d’*attributs*.
Cette section décrit comment écrire une ligne (ou un élément) dans une table.
**Topics**
+ [
## Écriture de données dans une table avec SQL
](#SQLtoNoSQL.WriteData.SQL)
+ [
## Écrire de données dans une table dans DynamoDB
](#SQLtoNoSQL.WriteData.DynamoDB)
## Écriture de données dans une table avec SQL
Une table d’une base de données relationnelle est une structure de données à deux dimensions, composée de lignes et de colonnes. Certains systèmes de gestion de base de données fournissent également la prise en charge des données semi-structurées, généralement avec les types de données natifs JSON ou XML. Cependant, les détails de la mise en œuvre varient selon les fournisseurs.
En SQL, l’ajout d’une ligne à une table s’effectue via l’instruction `INSERT`.
```
INSERT INTO Music
(Artist, SongTitle, AlbumTitle,
Year, Price, Genre,
Tags)
VALUES(
'No One You Know', 'Call Me Today', 'Somewhat Famous',
2015, 2.14, 'Country',
'{"Composers": ["Smith", "Jones", "Davis"],"LengthInSeconds": 214}'
);
```
La clé primaire de cette table comprend *Artist* et *SongTitle*. Vous devez spécifier les valeurs de ces colonnes.
**Note**
Cet exemple utilise la colonne *Tags* pour stocker les données semi-structurées sur les chansons de la table *Music*. La colonne *Tags* est définie au format TEXTE, ce qui permet de stocker jusqu’à 65 535 caractères dans MySQL.
## Écrire de données dans une table dans DynamoDB
Dans Amazon DynamoDB, vous pouvez ajouter un élément à 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.
```
{
TableName: "Music",
Item: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today",
"AlbumTitle":"Somewhat Famous",
"Year": 2015,
"Price": 2.14,
"Genre": "Country",
"Tags": {
"Composers": [
"Smith",
"Jones",
"Davis"
],
"LengthInSeconds": 214
}
}
}
```
La clé primaire de cette table comprend *Artist* et *SongTitle*. Vous devez spécifier les valeurs de ces attributs.
Voici quelques éléments clés à savoir sur cet exemple `PutItem` :
+ DynamoDB assure une prise en charge native des documents à l’aide de JSON. Cela fait de DynamoDB un outil idéal pour stocker des données semi-structurées telles que des *étiquettes*. Vous pouvez également récupérer et manipuler les données à partir des documents JSON.
+ La table *Music* ne possède aucun attribut prédéfini, à l'exception de la clé primaire (*Artist* et *SongTitle*).
+ La plupart des bases de données SQL sont orientées transactions. Lorsque vous émettez une instruction `INSERT`, les modifications des données ne sont pas permanentes jusqu’à ce que vous lanciez une instruction `COMMIT`. Avec Amazon DynamoDB, les effets d’une opération `PutItem` sont permanents lorsque DynamoDB répond par un code d’état HTTP 200 (`OK`).
Voici quelques autres exemples de `PutItem`.
```
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle":"Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle":"Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Still In Love",
"AlbumTitle":"The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying":[
"KHCR", "KBQX", "WTNR", "WJJH"
],
"TourDates": {
"Seattle": "20150625",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle":"The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
}
```
**Note**
En plus de `PutItem`, DynamoDB prend en charge une opération `BatchWriteItem` pour écrire plusieurs éléments à la fois.
------
#### [ PartiQL for DynamoDB ]
Avec PartiQL, vous utilisez l’opération `ExecuteStatement` pour ajouter un élément à une table, à l’aide de l’instruction PartiQL `Insert`.
```
INSERT into Music value {
'Artist': 'No One You Know',
'SongTitle': 'Call Me Today',
'AlbumTitle': 'Somewhat Famous',
'Year' : '2015',
'Genre' : 'Acme'
}
```
La clé primaire de cette table comprend *Artist* et *SongTitle*. Vous devez spécifier les valeurs de ces attributs.
**Note**
Pour des exemples de code utilisant `Insert` et `ExecuteStatement`, consultez [Instructions d’insertion de PartiQL pour DynamoDB](ql-reference.insert.md).
------
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la lecture de données à partir d’une table
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
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
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
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
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
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
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
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
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
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).
------
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la gestion d’index
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
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
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
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
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
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
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).
------
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la modification de données dans une table
Le langage SQL fournit l’instruction `UPDATE` pour modifier les données. Amazon DynamoDB utilise l’opération `UpdateItem` pour accomplir des tâches similaires.
**Topics**
+ [
## Modification de données dans une table avec SQL
](#SQLtoNoSQL.UpdateData.SQL)
+ [
## Modification de données dans une table dans DynamoDB
](#SQLtoNoSQL.UpdateData.DynamoDB)
## Modification de données dans une table avec SQL
En SQL, la modification d’une ou plusieurs lignes s’effectue via l’instruction `UPDATE`. La clause `SET` spécifie de nouvelles valeurs pour une ou plusieurs colonnes, et la clause `WHERE` détermine les lignes qui sont modifiées. Voici un exemple.
```
UPDATE Music
SET RecordLabel = 'Global Records'
WHERE Artist = 'No One You Know' AND SongTitle = 'Call Me Today';
```
Si aucune ligne ne correspond à la clause `WHERE`, l’instruction `UPDATE` n’a aucun effet.
## Modification de données dans une table dans DynamoDB
Dans DynamoDB, vous pouvez modifier un élément unique à 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). Si vous voulez modifier plusieurs éléments, vous devez utiliser plusieurs opérations.
------
#### [ DynamoDB API ]
Avec l’API DynamoDB, vous devez utiliser l’opération `UpdateItem` pour modifier un élément unique.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ExpressionAttributeValues: {
":label": "Global Records"
}
}
```
Vous devez spécifier les attributs `Key` de l’élément à modifier ainsi qu’une `UpdateExpression` pour spécifier les valeurs des attributs. `UpdateItem` se comporte comme une opération « upsert » (mise à jour/insertion). L’élément est mis à jour s’il existe dans la table, mais dans le cas contraire, un nouvel élément est ajouté (inséré).
`UpdateItem` prend en charge les *écritures conditionnelles*, où l’opération aboutit uniquement si un attribut `ConditionExpression` a la valeur true. Par exemple, l’opération `UpdateItem` suivante n’effectue pas la mise à jour, sauf si le prix de la chanson est supérieur ou égal à 2,00.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ConditionExpression: "Price >= :p",
ExpressionAttributeValues: {
":label": "Global Records",
":p": 2.00
}
}
```
`UpdateItem` prend également en charge les *compteurs atomiques*, ou les attributs de type `Number` qui peuvent être incrémentés ou décrémentés. Les compteurs atomiques sont similaires en de nombreuses façons aux générateurs de séquence, aux colonnes d’identité ou aux champs d’incrémentation automatique dans les bases de données SQL.
Voici un exemple d’opération `UpdateItem` pour initialiser un nouvel attribut (*Plays*) et suivre le nombre de fois qu’une chanson a été écoutée.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = :val",
ExpressionAttributeValues: {
":val": 0
},
ReturnValues: "UPDATED_NEW"
}
```
Le paramètre `ReturnValues` est défini sur `UPDATED_NEW`, qui retourne les nouvelles valeurs de tous les attributs qui ont été mis à jour. Dans ce cas, la valeur 0 (zéro) est retournée.
Chaque fois que quelqu’un écoute cette chanson, nous pouvons utiliser l’opération `UpdateItem` suivante pour incrémenter la valeur *Plays* d’une unité.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = Plays + :incr",
ExpressionAttributeValues: {
":incr": 1
},
ReturnValues: "UPDATED_NEW"
}
```
------
#### [ PartiQL for DynamoDB ]
Avec PartiQL, vous utilisez l’opération `ExecuteStatement` pour modifier un élément d’une table, à l’aide de l’instruction PartiQL `Update`.
La clé primaire de cette table comprend *Artist* et *SongTitle*. Vous devez spécifier les valeurs de ces attributs.
```
UPDATE Music
SET RecordLabel ='Global Records'
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
Vous pouvez également modifier plusieurs champs à la fois, tel qu’illustré dans l’exemple suivant.
```
UPDATE Music
SET RecordLabel = 'Global Records'
SET AwardsWon = 10
WHERE Artist ='No One You Know' AND SongTitle='Call Me Today'
```
`Update` prend également en charge les *compteurs atomiques*, ou les attributs de type `Number` qui peuvent être incrémentés ou décrémentés. Les compteurs atomiques sont similaires en de nombreuses façons aux générateurs de séquence, aux colonnes d’identité ou aux champs d’incrémentation automatique dans les bases de données SQL.
Voici un exemple d’instruction `Update` destinée à initialiser un nouvel attribut (*Plays* (Lectures)) et à suivre le nombre de fois où un morceau a été joué.
```
UPDATE Music
SET Plays = 0
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
Chaque fois que quelqu’un écoute ce morceau, nous pouvons utiliser l’instruction `Update` suivante pour incrémenter la valeur *Plays* (Lectures) d’une unité.
```
UPDATE Music
SET Plays = Plays + 1
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
**Note**
Pour des exemples de code utilisant `Update` et `ExecuteStatement`, consultez [Instructions de mise à jour de PartiQL pour DynamoDB](ql-reference.update.md).
------
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la suppression de données dans une table
Dans SQL, l’instruction `DELETE` supprime une ou plusieurs lignes d’une table. Amazon DynamoDB utilise l’opération `DeleteItem` pour supprimer un élément à la fois.
**Topics**
+ [
## Suppression de données d’une table avec SQL
](#SQLtoNoSQL.DeleteData.SQL)
+ [
## Suppression de données d’une table dans DynamoDB
](#SQLtoNoSQL.DeleteData.DynamoDB)
## Suppression de données d’une table avec SQL
Dans SQL, vous utilisez l’instruction `DELETE` pour supprimer une ou plusieurs lignes. La clause `WHERE` détermine les lignes que vous voulez modifier. Voici un exemple.
```
DELETE FROM Music
WHERE Artist = 'The Acme Band' AND SongTitle = 'Look Out, World';
```
Vous pouvez modifier la clause `WHERE` pour supprimer plusieurs lignes. Par exemple, vous pouvez supprimer tous les morceaux d’un artiste particulier, comme illustré dans l’exemple ci-après :
```
DELETE FROM Music WHERE Artist = 'The Acme Band'
```
## Suppression de données d’une table dans DynamoDB
Dans DynamoDB, vous pouvez supprimer un élément unique à 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). Si vous voulez modifier plusieurs éléments, vous devez utiliser plusieurs opérations.
------
#### [ DynamoDB API ]
Avec l’API DynamoDB, vous devez utiliser l’opération `DeleteItem` pour supprimer les données d’une table, un élément à la fois. Vous devez spécifier les valeurs de clé primaire de l’élément.
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
}
}
```
**Note**
Outre `DeleteItem`, Amazon DynamoDB prend en charge une opération `BatchWriteItem` pour supprimer plusieurs éléments à la fois.
`DeleteItem` prend en charge les *écritures conditionnelles*, où l’opération aboutit uniquement si un attribut `ConditionExpression` a la valeur true. Par exemple, l'`DeleteItem`opération suivante supprime l'élément uniquement s'il possède un *RecordLabel*attribut.
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
},
ConditionExpression: "attribute_exists(RecordLabel)"
}
```
------
#### [ PartiQL for DynamoDB ]
Avec PartiQL, vous utilisez l’instruction `Delete` via l’opération `ExecuteStatement` afin de supprimer des données d’une table, un élément à la fois. Vous devez spécifier les valeurs de clé primaire de l’élément.
La clé primaire de cette table comprend *Artist* et *SongTitle*. Vous devez spécifier les valeurs de ces attributs.
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks'
```
Vous pouvez également spécifier des conditions supplémentaires pour l’opération. L’opération `DELETE` suivante ne supprime l’élément que s’il a plus de 11 *Awards* (Récompenses).
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks' AND Awards > 11
```
**Note**
Pour des exemples de code utilisant `DELETE` et `ExecuteStatement`, consultez [Instructions de suppression de PartiQL pour DynamoDB](ql-reference.delete.md).
------
# Différences entre une base de données relationnelle (SQL) et DynamoDB lors de la suppression d’une table
Dans SQL, vous utilisez l’instruction `DROP TABLE` pour supprimer une table. Dans Amazon DynamoDB, vous utilisez l’opération `DeleteTable`.
**Topics**
+ [
## Suppression d’une table avec SQL
](#SQLtoNoSQL.RemoveTable.SQL)
+ [
## Suppression d’une table dans DynamoDB
](#SQLtoNoSQL.RemoveTable.DynamoDB)
## Suppression d’une table avec SQL
Lorsque vous n’avez plus besoin d’une table et que vous voulez la supprimer définitivement, vous devez utiliser l’instruction `DROP TABLE` en SQL.
```
DROP TABLE Music;
```
Une fois qu’une table est supprimée, elle ne peut pas être récupérée. (Certaines bases de données relationnelles vous permettent réellement d’annuler une opération `DROP TABLE`, mais il s’agit d’une fonctionnalité propre au fournisseur et qui n’est pas largement appliquée.)
## Suppression d’une table dans DynamoDB
Dans DynamoDB, `DeleteTable` est une opération similaire. Dans l’exemple suivant, la table est supprimée de façon définitive.
```
{
TableName: "Music"
}
```