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. # PartiQL – Langage de requête compatible SQL pour Amazon DynamoDB Amazon DynamoDB prend en charge [PartiQL](https://partiql.org/), un langage de requête compatible SQL, pour sélectionner, insérer, mettre à jour et supprimer des données dans Amazon DynamoDB. Grâce à PartiQL, vous pouvez facilement interagir avec les tables DynamoDB et exécuter des requêtes ad hoc à l'aide de AWS Management Console NoSQL Workbench et de DynamoDB pour PartiQL. AWS Command Line Interface APIs Les opérations PartiQL offrent une disponibilité, une latence et des performances identiques aux autres opérations de plan de données DynamoDB. Les sections suivantes décrivent l’implémentation DynamoDB de PartiQL. **Topics** + [Qu’est-ce que PartiQL ?](#ql-reference.what-is) + [PartiQL dans Amazon DynamoDB](#ql-reference.what-is) + [Prise en main](ql-gettingstarted.md) + [Types de données](ql-reference.data-types.md) + [Instructions](ql-reference.statements.md) + [Fonctions](ql-functions.md) + [Opérateurs](ql-operators.md) + [Transactions](ql-reference.multiplestatements.transactions.md) + [Opérations par lots](ql-reference.multiplestatements.batching.md) + [politiques IAM](ql-iam.md) ## Qu’est-ce que PartiQL ? Le langage *PartiQL* fournit un accès aux requêtes compatible SQL sur plusieurs magasins de données contenant des données structurées, des données semi-structurées et des données imbriquées. Il est largement utilisé au sein d'Amazon et est désormais disponible dans le cadre de nombreux AWS services, dont DynamoDB. Pour la spécification de PartiQL et un didacticiel sur le langage de requête de base, consultez la [Documentation PartiQL](https://partiql.org/docs.html). **Note** Amazon DynamoDB prend en charge un *sous-ensemble* du langage de requête [PartiQL](https://partiql.org/). Amazon DynamoDB ne prend pas en charge le format de données [Amazon Ion](http://amzn.github.io/ion-docs/) ou les littéraux Amazon Ion. ## PartiQL dans Amazon DynamoDB Pour exécuter des requêtes PartiQL dans DynamoDB, vous pouvez utiliser les ressources suivantes : + La console DynamoDB + Le NoSQL Workbench + Le AWS Command Line Interface (AWS CLI) + Le DynamoDB APIs Pour plus d’informations sur l’utilisation de ces méthodes pour accéder à DynamoDB, consultez [Accès à DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html). # Mise en route avec PartiQL pour DynamoDB Cette section décrit comment utiliser PartiQL pour DynamoDB à partir de la console Amazon DynamoDB, du () et de DynamoDB. AWS Command Line Interface AWS CLI APIs Dans les exemples suivants, la table DynamoDB définie dans le didacticiel [Mise en route avec DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) est un prérequis. [Pour plus d'informations sur l'utilisation de la console DynamoDB ou de DynamoDB pour accéder à DynamoDB AWS Command Line Interface, consultez la section Accès à APIs DynamoDB.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html) Pour [télécharger](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.settingup.html) et utiliser le [NoSQL Workbench](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html) afin de créer des instructions [PartiQL pour DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), choisissez **PartiQL operations** (Opérations PartiQL) dans l’angle supérieur droit du NoSQL Workbench pour DynamoDB [Operation Builder](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.querybuilder.operationbuilder.html) (Créateur d’opérations). ------ #### [ Console ] ![\[Interface d’éditeur PartiQL qui affiche le résultat de l’exécution de l’opération Query sur la table Music.\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/images/partiqlgettingstarted.png) 1. Connectez-vous à la console DynamoDB AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Dans le panneau de navigation sur le côté gauche de la console, choisissez **PartiQL editor (Editeur PartiQL)**. 1. Choisissez la table **Music**. 1. Choisissez **Query table (Table de requête)**. Cette action génère une requête qui n’entraîne pas d’analyse de table complète. 1. Remplacez `partitionKeyValue` par la valeur de chaîne `Acme Band`. Remplacez `sortKeyValue` par la valeur de chaîne `Happy Day`. 1. Choisissez le bouton **Run (Exécuter)**. 1. Vous pouvez afficher les résultats de la requête en choisissant les boutons **Table view (Vue tableau)** ou **JSON view (Vue JSON)**. ------ #### [ NoSQL workbench ] ![\[Interface NoSQL Workbench. Il affiche une instruction PartiQL SELECT que vous pouvez exécuter sur la table Music.\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/images/workbench/partiql.single.png) 1. Choisissez **PartiQL statement (Instruction PartiQL)**. 1. Entrez l’instruction PartiQL [SELECT](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html) suivante ``` SELECT * FROM Music WHERE Artist=? and SongTitle=? ``` 1. Pour spécifier une valeur pour les paramètres `Artist` et `SongTitle` : 1. Choisissez **Optional request parameters (Paramètres de demande facultatifs)**. 1. Choisissez **Add new parameters (Ajouter de nouveaux paramètres)**. 1. Choisissez le type d’attribut **string (chaîne)** et la valeur `Acme Band`. 1. Répétez les étapes b et c, puis choisissez le type **string (chaîne)** et la valeur `PartiQL Rocks`. 1. Si vous souhaitez générer un code, choisissez **Generate code (Générer un code)**. Sélectionnez votre langage souhaité dans les onglets affichés. Vous pouvez désormais copier ce code et l’utiliser dans votre application. 1. Si vous souhaitez que l’opération soit exécutée immédiatement, choisissez **Run (Exécuter)**. ------ #### [ AWS CLI ] 1. Créez un élément dans la table `Music` à l’aide de l’instruction INSERT PartiQL. ``` aws dynamodb execute-statement --statement "INSERT INTO Music \ VALUE \ {'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}" ``` 1. Extrayez un élément de la table Music à l’aide de l’instruction SELECT PartiQL. ``` aws dynamodb execute-statement --statement "SELECT * FROM Music \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` 1. Créez un élément dans la table `Music` à l’aide de l’instruction UPDATE PartiQL. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardsWon=1 \ SET AwardDetail={'Grammys':[2020, 2018]} \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Ajoutez une valeur de liste pour un élément dans la table `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Supprimez une valeur de liste pour un élément dans la table `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ REMOVE AwardDetail.Grammys[2] \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Ajoutez un nouveau membre de mappage pour un élément dans la table `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardDetail.BillBoard=[2020] \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Ajoutez un nouvel attribut d’ensemble de chaînes pour un élément dans la table `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET BandMembers =<<'member1', 'member2'>> \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Mettez à jour un attribut d’ensemble de chaînes pour un élément dans la table `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET BandMembers =set_add(BandMembers, <<'newmember'>>) \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` 1. Supprimez un élément de la table `Music` à l’aide de l’instruction PartiQL DELETE. ``` aws dynamodb execute-statement --statement "DELETE FROM Music \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` ------ #### [ Java ] ``` import java.util.ArrayList; import java.util.List; import com.amazonaws.AmazonClientException; import com.amazonaws.AmazonServiceException; import software.amazon.dynamodb.AmazonDynamoDB; import software.amazon.dynamodb.AmazonDynamoDBClientBuilder; import software.amazon.dynamodb.model.AttributeValue; import software.amazon.dynamodb.model.ConditionalCheckFailedException; import software.amazon.dynamodb.model.ExecuteStatementRequest; import software.amazon.dynamodb.model.ExecuteStatementResult; import software.amazon.dynamodb.model.InternalServerErrorException; import software.amazon.dynamodb.model.ItemCollectionSizeLimitExceededException; import software.amazon.dynamodb.model.ProvisionedThroughputExceededException; import software.amazon.dynamodb.model.RequestLimitExceededException; import software.amazon.dynamodb.model.ResourceNotFoundException; import software.amazon.dynamodb.model.TransactionConflictException; public class DynamoDBPartiQGettingStarted { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-1"); try { // Create ExecuteStatementRequest ExecuteStatementRequest executeStatementRequest = new ExecuteStatementRequest(); List parameters= getPartiQLParameters(); //Create an item in the Music table using the INSERT PartiQL statement processResults(executeStatementRequest(dynamoDB, "INSERT INTO Music value {'Artist':?,'SongTitle':?}", parameters)); //Retrieve an item from the Music table using the SELECT PartiQL statement. processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters)); //Update an item in the Music table using the UPDATE PartiQL statement. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist=? and SongTitle=?", parameters)); //Add a list value for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) where Artist=? and SongTitle=?", parameters)); //Remove a list value for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music REMOVE AwardDetail.Grammys[2] where Artist=? and SongTitle=?", parameters)); //Add a new map member for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music set AwardDetail.BillBoard=[2020] where Artist=? and SongTitle=?", parameters)); //Add a new string set attribute for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =<<'member1', 'member2'>> where Artist=? and SongTitle=?", parameters)); //update a string set attribute for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =set_add(BandMembers, <<'newmember'>>) where Artist=? and SongTitle=?", parameters)); //Retrieve an item from the Music table using the SELECT PartiQL statement. processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters)); //delete an item from the Music Table processResults(executeStatementRequest(dynamoDB, "DELETE FROM Music where Artist=? and SongTitle=?", parameters)); } catch (Exception e) { handleExecuteStatementErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static List getPartiQLParameters() { List parameters = new ArrayList(); parameters.add(new AttributeValue("Acme Band")); parameters.add(new AttributeValue("PartiQL Rocks")); return parameters; } private static ExecuteStatementResult executeStatementRequest(AmazonDynamoDB client, String statement, List parameters ) { ExecuteStatementRequest request = new ExecuteStatementRequest(); request.setStatement(statement); request.setParameters(parameters); return client.executeStatement(request); } private static void processResults(ExecuteStatementResult executeStatementResult) { System.out.println("ExecuteStatement successful: "+ executeStatementResult.toString()); } // Handles errors during ExecuteStatement execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleExecuteStatementErrors(Exception exception) { try { throw exception; } catch (ConditionalCheckFailedException ccfe) { System.out.println("Condition check specified in the operation failed, review and update the condition " + "check before retrying. Error: " + ccfe.getErrorMessage()); } catch (TransactionConflictException tce) { System.out.println("Operation was rejected because there is an ongoing transaction for the item, generally " + "safe to retry with exponential back-off. Error: " + tce.getErrorMessage()); } catch (ItemCollectionSizeLimitExceededException icslee) { System.out.println("An item collection is too large, you\'re using Local Secondary Index and exceeded " + "size limit of items per partition key. Consider using Global Secondary Index instead. Error: " + icslee.getErrorMessage()); } catch (Exception e) { handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ ## Utilisation d'instructions paramétrées Au lieu d'intégrer des valeurs directement dans une chaîne d'instruction PartiQL, vous pouvez utiliser des espaces réservés en forme de point d'interrogation `?` () et fournir les valeurs séparément dans le champ. `Parameters` Chacun `?` est remplacé par la valeur de paramètre correspondante, dans l'ordre dans lequel ils sont fournis. L'utilisation d'instructions paramétrées est une bonne pratique car elle sépare la structure des instructions des valeurs des données, ce qui facilite la lecture et la réutilisation des instructions. Cela évite également d'avoir à formater et à ignorer manuellement les valeurs d'attribut dans la chaîne de déclaration. Les instructions paramétrées sont prises en charge dans les `ExecuteStatement` opérations`BatchExecuteStatement`, et`ExecuteTransaction`. Les exemples suivants extraient un élément de la `Music` table à l'aide de valeurs paramétrées pour la clé de partition et la clé de tri. ------ #### [ AWS CLI parameterized ] ``` aws dynamodb execute-statement \ --statement "SELECT * FROM \"Music\" WHERE Artist=? AND SongTitle=?" \ --parameters '[{"S": "Acme Band"}, {"S": "PartiQL Rocks"}]' ``` ------ #### [ Java parameterized ] ``` List parameters = new ArrayList<>(); parameters.add(new AttributeValue("Acme Band")); parameters.add(new AttributeValue("PartiQL Rocks")); ExecuteStatementRequest request = new ExecuteStatementRequest() .withStatement("SELECT * FROM Music WHERE Artist=? AND SongTitle=?") .withParameters(parameters); ExecuteStatementResult result = dynamoDB.executeStatement(request); ``` ------ #### [ Python parameterized ] ``` response = dynamodb_client.execute_statement( Statement="SELECT * FROM Music WHERE Artist=? AND SongTitle=?", Parameters=[ {'S': 'Acme Band'}, {'S': 'PartiQL Rocks'} ] ) ``` ------ **Note** L'exemple Java présenté dans la section de démarrage précédente utilise des instructions paramétrées dans l'ensemble. La `getPartiQLParameters()` méthode crée la liste des paramètres, et chaque instruction utilise des `?` espaces réservés au lieu de valeurs intégrées. # Types de données PartiQL pour DynamoDB Le tableau suivant répertorie les types de données que vous pouvez utiliser avec PartiQL pour DynamoDB. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/amazondynamodb/latest/developerguide/ql-reference.data-types.html) ## Exemples L’instruction suivante montre comment insérer les types de données suivants : `String`, `Number`, `Map`, `List`, `Number Set` et `String Set`. ``` INSERT INTO TypesTable value {'primarykey':'1', 'NumberType':1, 'MapType' : {'entryname1': 'value', 'entryname2': 4}, 'ListType': [1,'stringval'], 'NumberSetType':<<1,34,32,4.5>>, 'StringSetType':<<'stringval','stringval2'>> } ``` L’instruction suivante montre comment insérer de nouveaux éléments dans les types `Map`, `List`, `Number Set` et `String Set`, et modifier la valeur d’un type `Number`. ``` UPDATE TypesTable SET NumberType=NumberType + 100 SET MapType.NewMapEntry=[2020, 'stringvalue', 2.4] SET ListType = LIST_APPEND(ListType, [4, <<'string1', 'string2'>>]) SET NumberSetType= SET_ADD(NumberSetType, <<345, 48.4>>) SET StringSetType = SET_ADD(StringSetType, <<'stringsetvalue1', 'stringsetvalue2'>>) WHERE primarykey='1' ``` L’instruction suivante montre comment supprimer des éléments des types `Map`, `List`, `Number Set` et `String Set`, et modifier la valeur d’un type `Number`. ``` UPDATE TypesTable SET NumberType=NumberType - 1 REMOVE ListType[1] REMOVE MapType.NewMapEntry SET NumberSetType = SET_DELETE( NumberSetType, <<345>>) SET StringSetType = SET_DELETE( StringSetType, <<'stringsetvalue1'>>) WHERE primarykey='1' ``` Pour plus d’informations, consultez [Types de données DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes). # Instructions PartiQL pour DynamoDB Amazon DynamoDB prend en charge les instructions PartiQL suivantes. **Note** DynamoDB ne prend pas en charge toutes les instructions PartiQL. Cette référence fournit des exemples de syntaxe de base et d'utilisation des instructions partiQL que vous exécutez manuellement à l'aide de la AWS CLI commande or. APIs Le *langage de manipulation des données* (Data manipulation language, DML) est l’ensemble d’instructions PartiQL que vous utilisez pour gérer les données dans des tables DynamoDB. Vous utilisez des instructions DML pour ajouter, modifier ou supprimer des données dans une table. Les instructions DML et de langage de requête prises en charge sont les suivantes : + [Instructions PartiQL de sélection pour DynamoDB](ql-reference.select.md) + [Instructions de mise à jour de PartiQL pour DynamoDB](ql-reference.update.md) + [Instructions d’insertion de PartiQL pour DynamoDB](ql-reference.insert.md) + [Instructions de suppression de PartiQL pour DynamoDB](ql-reference.delete.md) Les instructions [Exécution de transactions avec PartiQL pour DynamoDB](ql-reference.multiplestatements.transactions.md) et [Exécution d’opérations par lot avec PartiQL pour DynamoDB](ql-reference.multiplestatements.batching.md) sont également prises en charge par PartiQL pour DynamoDB. # Instructions PartiQL de sélection pour DynamoDB Utilisez l’instruction `SELECT` pour extraire des données d’une table dans Amazon DynamoDB. L’utilisation de l’instruction `SELECT` peut entraîner une analyse de table complète si une condition IN avec une clé de partition n’est pas fournie dans la clause WHERE. Une opération d’analyse examine chaque élément en lien avec les valeurs demandées, et peut utiliser tout le débit approvisionné pour une table ou un index volumineux en une seule opération. Si vous voulez éviter une analyse de table complète dans PartiQL, vous pouvez : + Créer vos instructions `SELECT` de façon à ce qu’elle n’entraînent pas d’analyse de table complète en vous assurant que votre [condition de clause WHERE](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html#ql-reference.select.parameters) est configurée en conséquence. + Désactiver l’analyse de table complète à l’aide de la politique IAM spécifiée dans [Exemple : autoriser les instructions de sélection et rejeter les instructions d’analyse de table complète dans PartiQL pour DynamoDB](ql-iam.md#access-policy-ql-iam-example6), dans le Manuel du développeur DynamoDB. Pour plus d’informations, consultez [Bonnes pratiques pour l’interrogation et l’analyse des données](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-query-scan.html) dans le Guide du développeur DynamoDB. **Topics** + [Syntaxe](#ql-reference.select.syntax) + [Parameters](#ql-reference.select.parameters) + [Exemples](#ql-reference.select.examples) ## Syntaxe ``` SELECT expression [, ...] FROM table[.index] [ WHERE condition ] [ [ORDER BY key [DESC|ASC] , ...] ``` ## Parameters ***expression*** (Obligatoire) Projection formée à partir du caractère générique `*` ou d’une liste de projection d’un ou de plusieurs noms d’attributs ou chemins d’accès de documents de l’ensemble de résultats. Une expression peut être constituée d’appels à [Utilisation de fonctions PartiQL avec DynamoDB](ql-functions.md) ou de champs modifiés par [Opérateurs arithmétiques, de comparaison et logiques PartiQL pour DynamoDB](ql-operators.md). ***table*** (Obligatoire) Nom de la table à interroger. ***index*** (Facultatif) Nom de l’index à interroger. Vous devez ajouter des guillemets doubles au nom de la table et au nom de l’index lorsque vous interrogez un index. ``` SELECT * FROM "TableName"."IndexName" ``` ***condition*** (Facultatif) Critères de sélection pour la requête. Pour s’assurer qu’une instruction `SELECT` n’entraîne pas une analyse de table complète, la condition de clause `WHERE` doit spécifier une clé de partition. Utilisez l’opérateur d’égalité ou IN (DANS). Par exemple, si vous avez une table `Orders` avec une clé de partition `OrderID` et des attributs autres que de clé, dont une `Address`, les instructions suivantes n’entraînent pas d’analyse de table complète : ``` SELECT * FROM "Orders" WHERE OrderID = 100 SELECT * FROM "Orders" WHERE OrderID = 100 and Address='some address' SELECT * FROM "Orders" WHERE OrderID = 100 or OrderID = 200 SELECT * FROM "Orders" WHERE OrderID IN [100, 300, 234] ``` En revanche, les instructions `SELECT` suivantes entraînent une analyse de table complète : ``` SELECT * FROM "Orders" WHERE OrderID > 1 SELECT * FROM "Orders" WHERE Address='some address' SELECT * FROM "Orders" WHERE OrderID = 100 OR Address='some address' ``` ***key*** (Facultatif) Clé de hachage ou clé de tri à utiliser pour ordonner les résultats renvoyés. L’ordre par défaut est croissant (`ASC`). Spécifiez `DESC` si vous voulez que les résultats soient réordonnés dans l’ordre décroissant. **Note** Si vous omettez la clause `WHERE`, tous les éléments de la table sont extraits. ## Exemples La requête suivante renvoie un élément existant de la table `Orders` en spécifiant la clé de partition, `OrderID`, et en utilisant l’opérateur d’égalité. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID = 1 ``` La requête suivante renvoie tous les éléments de la table `Orders` ayant une clé de partition spécifique, `OrderID`, et leurs valeurs en utilisant l’opérateur OR (OU). ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID = 1 OR OrderID = 2 ``` La requête suivante renvoie tous les éléments de la table `Orders` ayant une clé de partition spécifique, `OrderID`, et leurs valeurs en utilisant l’opérateur IN (DANS). Les résultats renvoyés sont dans l’ordre décroissant de la valeur de leur attribut de clé `OrderID`. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID IN [1, 2, 3] ORDER BY OrderID DESC ``` La requête suivante affiche une analyse de table complète qui renvoie tous les éléments de la table `Orders` dont la valeur `Total` est supérieure à 500, où `Total` est un attribut autre que de clé. ``` SELECT OrderID, Total FROM "Orders" WHERE Total > 500 ``` La requête suivante affiche une analyse de table complète qui renvoie tous les éléments de la table `Orders`dans une plage `Total` spécifique, en utilisant l’opérateur IN (DANS) et un attribut autre que de clé `Total`. ``` SELECT OrderID, Total FROM "Orders" WHERE Total IN [500, 600] ``` La requête suivante affiche une analyse de table complète qui renvoie tous les éléments de la table `Orders`dans une plage `Total` spécifique, en utilisant l’opérateur BETWEEN (ENTRE) et un attribut autre que de clé `Total`. ``` SELECT OrderID, Total FROM "Orders" WHERE Total BETWEEN 500 AND 600 ``` La requête suivante renvoie la première date à laquelle un Firestick a été utilisé, en spécifiant la clé de partition `CustomerID` et une clé de tri `MovieID` dans la condition de clause WHERE, et en utilisant des chemins d’accès de document dans la clause SELECT. ``` SELECT Devices.FireStick.DateWatched[0] FROM WatchList WHERE CustomerID= 'C1' AND MovieID= 'M1' ``` La requête suivante affiche une analyse de table complète qui renvoie la liste des éléments pour lesquels un Firestick a été utilisé pour la première fois après le 24/12/19, en utilisant des chemins de document dans la condition de la clause WHERE. ``` SELECT Devices FROM WatchList WHERE Devices.FireStick.DateWatched[0] >= '12/24/19' ``` # Instructions de mise à jour de PartiQL pour DynamoDB Utilisez l’instruction `UPDATE` pour modifier la valeur d’un ou de plusieurs attributs dans un élément d’une table Amazon DynamoDB. **Note** Vous ne pouvez mettre à jour qu’un seul élément à la fois et ne pouvez pas émettre une instruction PartiQL pour DynamoDB qui met à jour plusieurs éléments. Pour plus d’informations sur la mise à jour de plusieurs éléments, consultez [Exécution de transactions avec PartiQL pour DynamoDB](ql-reference.multiplestatements.transactions.md) ou [Exécution d’opérations par lot avec PartiQL pour DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Syntaxe](#ql-reference.update.syntax) + [Parameters](#ql-reference.update.parameters) + [Valeur renvoyée](#ql-reference.update.return) + [Exemples](#ql-reference.update.examples) ## Syntaxe ``` UPDATE table [SET | REMOVE] path [= data] […] WHERE condition [RETURNING returnvalues] ::= [ALL OLD | MODIFIED OLD | ALL NEW | MODIFIED NEW] * ``` ## Parameters ***table*** (Obligatoire) Table contenant les données à modifier. ***path*** (Obligatoire) Nom d’attribut ou chemin d’accès de document à créer ou à modifier. ***data*** (Obligatoire) Valeur d’attribut ou résultat d’une opération. Opérations prises en charge à utiliser avec SET : + LIST\$1APPEND : ajoute une valeur à un type de liste. + SET\$1ADD : ajoute une valeur à un ensemble de nombres ou de chaînes. + SET\$1DELETE : supprime une valeur d’un ensemble de nombres ou de chaînes. ***condition*** (Obligatoire) Critères de sélection de l’élément à modifier. Le résultat de cette condition doit être une seule valeur de clé primaire. ***returnvalues*** (Facultatif) Utilisez `returnvalues` si vous souhaitez obtenir les attributs de l’élément avant ou après sa mise à jour. Les valeurs valides sont : + `ALL OLD *` – Renvoie tous les attributs de l’élément avant l’opération de mise à jour. + `MODIFIED OLD *` – Renvoie uniquement les attributs mis à jour avant l’opération de mise à jour. + `ALL NEW *` – Renvoie tous les attributs de l’élément après l’opération de mise à jour. + `MODIFIED NEW *` – Renvoie uniquement les attributs mis à jour après l’opération `UpdateItem`. ## Valeur renvoyée Cette instruction ne renvoie de valeur que si le paramètre `returnvalues` est spécifié. **Note** Si la clause WHERE de l’instruction UPDATE ne produit le résultat true pour aucun élément de la table DynamoDB, `ConditionalCheckFailedException` est renvoyé. ## Exemples Mettez à jour une valeur d’attribut d’un élément existant. Si l’attribut n’existe pas, il est créé. La requête suivante met à jour un élément dans la table `"Music"` en ajoutant un attribut de type Number (`AwardsWon`) et un attribut de type Map (`AwardDetail`). ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Vous pouvez ajouter `RETURNING ALL OLD *` pour renvoyer les attributs tels qu’ils apparaissaient avant l’opération `Update`. ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' RETURNING ALL OLD * ``` Ceci renvoie les informations suivantes : ``` { "Items": [ { "Artist": { "S": "Acme Band" }, "SongTitle": { "S": "PartiQL Rocks" } } ] } ``` Vous pouvez ajouter `RETURNING ALL NEW *` pour renvoyer les attributs tels qu’ils sont apparus après l’opération `Update`. ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' RETURNING ALL NEW * ``` Ceci renvoie les informations suivantes : ``` { "Items": [ { "AwardDetail": { "M": { "Grammys": { "L": [ { "N": "2020" }, { "N": "2018" } ] } } }, "AwardsWon": { "N": "1" } } ] } ``` La requête suivante met à jour un élément dans la table `"Music"` en effectuant un ajout à une liste `AwardDetail.Grammys`. ``` UPDATE "Music" SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` La requête suivante met à jour un élément dans la table `"Music"` en effectuant une suppression d’une liste `AwardDetail.Grammys`. ``` UPDATE "Music" REMOVE AwardDetail.Grammys[2] WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` La requête suivante met à jour un élément dans la table `"Music"` en ajoutant `BillBoard` au mappage `AwardDetail`. ``` UPDATE "Music" SET AwardDetail.BillBoard=[2020] WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` La requête suivante met à jour un élément dans la table `"Music"` en ajoutant l’attribut d’ensemble de chaînes `BandMembers`. ``` UPDATE "Music" SET BandMembers =<<'member1', 'member2'>> WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` La requête suivante met à jour un élément dans la table `"Music"` en ajoutant `newbandmember` à l’ensemble de chaînes `BandMembers`. ``` UPDATE "Music" SET BandMembers =set_add(BandMembers, <<'newbandmember'>>) WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` # Instructions de suppression de PartiQL pour DynamoDB Utilisez l’instruction `DELETE` pour supprimer un élément existant de votre table Amazon DynamoDB. **Note** Vous ne pouvez supprimer qu’un seul élément à la fois. Vous ne pouvez pas émettre une seule instruction PartiQL pour DynamoDB qui supprime plusieurs éléments. Pour plus d’informations sur la suppression de plusieurs éléments, consultez [Exécution de transactions avec PartiQL pour DynamoDB](ql-reference.multiplestatements.transactions.md) ou [Exécution d’opérations par lot avec PartiQL pour DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Syntaxe](#ql-reference.delete.syntax) + [Parameters](#ql-reference.delete.parameters) + [Valeur renvoyée](#ql-reference.delete.return) + [Exemples](#ql-reference.delete.examples) ## Syntaxe ``` DELETE FROM table WHERE condition [RETURNING returnvalues] ::= ALL OLD * ``` ## Parameters ***table*** (Obligatoire) Table DynamoDB contenant l’élément à supprimer. ***condition*** (Obligatoire) Critères de sélection de l’élément à supprimer. Le résultat de cette condition doit être une seule valeur de clé primaire. ***returnvalues*** (Facultatif) Utilisez `returnvalues` si vous souhaitez obtenir les attributs de l’élément avant sa suppression. Les valeurs valides sont : + `ALL OLD *` – Le contenu de l’ancien élément est renvoyé. ## Valeur renvoyée Cette instruction ne renvoie de valeur que si le paramètre `returnvalues` est spécifié. **Note** Si la table DynamoDB ne contient aucun élément dont la même clé primaire est la même que celle de l’élément pour lequel l’instruction DELETE est émise, le résultat SUCCESS est renvoyé avec 0 élément supprimé. Si la table contient un élément avec la même clé primaire, mais que le résultat de la condition dans la clause WHERE de l’instruction DELETE est false (faux), l’erreur `ConditionalCheckFailedException` est renvoyée. ## Exemples La requête suivante interroge un élément dans la table `"Music"`. ``` DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' ``` Vous pouvez ajouter le paramètre `RETURNING ALL OLD *` pour renvoyer les données supprimées. ``` DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' RETURNING ALL OLD * ``` L’instruction `Delete` renvoie désormais ce qui suit : ``` { "Items": [ { "Artist": { "S": "Acme Band" }, "SongTitle": { "S": "PartiQL Rocks" } } ] } ``` # Instructions d’insertion de PartiQL pour DynamoDB Utilisez l’instruction `INSERT` pour ajouter un élément à une table dans Amazon DynamoDB. **Note** Vous ne pouvez insérer qu’un seul élément à la fois et ne pouvez pas émettre une instruction PartiQL pour DynamoDB qui insère plusieurs éléments. Pour plus d’informations sur l’insertion de plusieurs éléments, consultez [Exécution de transactions avec PartiQL pour DynamoDB](ql-reference.multiplestatements.transactions.md) ou [Exécution d’opérations par lot avec PartiQL pour DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Syntaxe](#ql-reference.insert.syntax) + [Parameters](#ql-reference.insert.parameters) + [Valeur renvoyée](#ql-reference.insert.return) + [Exemples](#ql-reference.insert.examples) ## Syntaxe Insérez un seul élément. ``` INSERT INTO table VALUE item ``` ## Parameters ***table*** (Obligatoire) Table dans laquelle vous souhaitez insérer les données. La table doit déjà exister. ***item*** (Obligatoire) Elément DynamoDB valide représenté sous la forme d’un [Tuple PartiqL](https://partiql.org/docs.html). Vous devez spécifier *un seul* élément. Chaque nom d’attribut dans l’élément est sensible à la casse et peut être indiqué par des *apostrophes* (`'...'`) dans PartiQL. Les valeurs de chaîne sont également indiquées par des *apostrophes* (`'...'`) dans PartiQL. ## Valeur renvoyée Cette instruction ne renvoie aucune valeur. **Note** Si la table DynamoDB contient déjà un élément avec la même clé primaire que la clé primaire de l’élément inséré, l’erreur `DuplicateItemException` est renvoyée. ## Exemples ``` INSERT INTO "Music" value {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'} ``` # Utilisation de fonctions PartiQL avec DynamoDB PartiQL dans Amazon DynamoDB prend en charge les variantes intégrées suivantes des fonctions standard SQL. **Note** Les fonctions SQL qui ne figurent pas dans cette liste ne sont actuellement pas prises en charge dans DynamoDB. ## Fonctions d’agrégation + [Utilisation de la fonction SIZE avec PartiQL pour Amazon DynamoDB](ql-functions.size.md) ## Fonctions conditionnelles + [Utilisation de la fonction EXISTS avec PartiQL pour DynamoDB](ql-functions.exists.md) + [Utilisation de la fonction ATTRIBUTE\$1TYPE avec PartiQL pour DynamoDB](ql-functions.attribute_type.md) + [Utilisation de la fonction BEGINS\$1WITH avec PartiQL pour DynamoDB](ql-functions.beginswith.md) + [Utilisation de la fonction CONTAINS avec PartiQL pour DynamoDB](ql-functions.contains.md) + [Utilisation de la fonction MISSING avec PartiQL pour DynamoDB](ql-functions.missing.md) # Utilisation de la fonction EXISTS avec PartiQL pour DynamoDB Vous pouvez utiliser la fonction EXISTS pour effectuer la même opération que la fonction `ConditionCheck` dans l’API [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems). Vous ne pouvez utiliser la fonction EXISTS que dans les transactions. Pour une valeur donnée, la fonction renvoie `TRUE` si la valeur est une collection non vide. Sinon, la valeur renvoyée est `FALSE`. **Note** Vous ne pouvez utiliser cette fonction que dans les opérations transactionnelles. ## Syntaxe ``` EXISTS ( statement ) ``` ## Arguments *statement* (Obligatoire) Instruction SELECT que la fonction évalue. L’instruction SELECT doit spécifier une clé primaire complète et une autre condition. ## Type de retour `bool` ## Exemples ``` EXISTS( SELECT * FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks') ``` # Utilisation de la fonction BEGINS\$1WITH avec PartiQL pour DynamoDB La fonction renvoie `TRUE` si l’attribut spécifié commence par une sous-chaîne particulière. ## Syntaxe ``` begins_with(path, value ) ``` ## Arguments *path* (Obligatoire) Chemin d’accès du nom d’attribut ou du document à utiliser. *valeur* (Obligatoire) Chaîne à rechercher. ## Type de retour `bool` ## Exemples ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND begins_with("Address", '7834 24th') ``` # Utilisation de la fonction MISSING avec PartiQL pour DynamoDB La fonction renvoie `TRUE` si l’élément ne contient pas l’attribut spécifié. Seuls des opérateurs d’égalité et d’inégalité peuvent être utilisés avec cette fonction. ## Syntaxe ``` attributename IS | IS NOT MISSING ``` ## Arguments *attributename* (Obligatoire) Nom d’attribut à rechercher. ## Type de retour `bool` ## Exemples ``` SELECT * FROM Music WHERE "Awards" is MISSING ``` # Utilisation de la fonction ATTRIBUTE\$1TYPE avec PartiQL pour DynamoDB La fonction renvoie `TRUE` si l’attribut dans le chemin d’accès spécifié est d’un type de données particulier. ## Syntaxe ``` attribute_type( attributename, type ) ``` ## Arguments *attributename* (Obligatoire) Nom d’attribut à utiliser. *type* (Obligatoire) Type d’attribut à vérifier. Pour obtenir la liste des valeurs valides, consultez [attribute\$1type](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) DynamoDB. ## Type de retour `bool` ## Exemples ``` SELECT * FROM "Music" WHERE attribute_type("Artist", 'S') ``` # Utilisation de la fonction CONTAINS avec PartiQL pour DynamoDB La fonction renvoie `TRUE` si l’attribut spécifié par le chemin d’accès est l’un des attributs suivants : + Une chaîne contenant une sous-chaîne particulière. + Un ensemble contenant un élément particulier. Pour plus d’informations, consultez la fonction DynamoDB [contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions). ## Syntaxe ``` contains( path, substring ) ``` ## Arguments *path* (Obligatoire) Chemin d’accès du nom d’attribut ou du document à utiliser. *substring* (Obligatoire) Sous-chaîne d’attribut ou membre d’ensemble à vérifier. Pour plus d’informations, consultez la fonction DynamoDB [contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions). ## Type de retour `bool` ## Exemples ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND contains("Address", 'Kirkland') ``` # Utilisation de la fonction SIZE avec PartiQL pour Amazon DynamoDB Renvoie un nombre représentant la taille en octets d’un attribut. Les types de données valides à utiliser avec la fonction Size sont les suivants. Pour plus d’informations, consultez la fonction DynamoDB [size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions). ## Syntaxe ``` size( path) ``` ## Arguments *path* (Obligatoire) Chemin d’accès du nom d’attribut ou du document à utiliser. Pour les types pris en charge, consultez la fonction DynamoDB [size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions). ## Type de retour `int` ## Exemples ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND size("Image") >300 ``` # Opérateurs arithmétiques, de comparaison et logiques PartiQL pour DynamoDB PartiQL dans Amazon DynamoDB prend en charge les [opérateurs standard SQL](https://www.w3schools.com/sql/sql_operators.asp) suivants. **Note** Les opérateurs SQL qui ne figurent pas dans cette liste ne sont actuellement pas pris en charge dans DynamoDB. ## Opérateurs arithmétiques **** | Opérateur | Description | | --- | --- | | \$1 | Addition | | - | Soustraction | ## Opérateurs de comparaison **** | Opérateur | Description | | --- | --- | | = | Egal à | | <> | Non égal à | | \$1= | Non égal à | | > | Supérieure à | | < | Inférieur à | | >= | Supérieur ou égal à | | <= | Inférieur ou égal à | ## Opérateurs logiques **** | Opérateur | Description | | --- | --- | | AND | TRUE si toutes les conditions séparées par AND sont TRUE | | BETWEEN | `TRUE` si l’opérande est comprise dans la plage des comparaisons. Cet opérateur inclut les limites inférieure et supérieure des opérandes auxquels vous l’appliquez. | | IN | `TRUE`si l'opérande est égal à l'une d'une liste d'expressions (au maximum 50 valeurs d'attribut de hachage ou au maximum 100 valeurs d'attributs non clés). Les résultats sont affichés sous forme de pages contenant jusqu'à 10 éléments. Si la `IN` liste contient plus de valeurs, vous devez utiliser les valeurs `NextToken` renvoyées dans la réponse pour récupérer les pages suivantes. | | IS | TRUE si l’opérande est un type de données PartiQL spécifique, dont NULL ou MISSING | | NOT | Inverse la valeur d’une expression booléenne donnée | | OR | TRUE si une ou plusieurs des conditions séparées par OR sont TRUE | Pour plus d’informations sur l’utilisation des opérateurs logiques, consultez [Comparaisons](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.Comparators) et [Évaluations logiques](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.LogicalEvaluations). # Exécution de transactions avec PartiQL pour DynamoDB Cette section décrit comment utiliser des transactions avec PartiQL pour DynamoDB. Les transactions PartiQL sont limitées à 100 instructions (actions) au total. Pour plus d’informations sur les transactions DynamoDB, consultez [Gestion des flux de travail complexes avec les transactions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html). **Note** La transaction entière doit être composée d’instructions de lecture ou d’instructions d’écriture. Vous ne pouvez pas mélanger les deux dans une seule transaction. La fonction EXISTS est une exception. Vous pouvez l'utiliser pour vérifier l'état d'attributs spécifiques de l'article de la même manière que dans le cadre de `ConditionCheck` l'opération [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems)d'API. **Topics** + [Syntaxe](#ql-reference.multiplestatements.transactions.syntax) + [Parameters](#ql-reference.multiplestatements.transactions.parameters) + [Valeurs renvoyées](#ql-reference.multiplestatements.transactions.return) + [Exemples](#ql-reference.multiplestatements.transactions.examples) ## Syntaxe ``` [ { "Statement":" statement ", "Parameters":[ { " parametertype " : " parametervalue " }, ...] } , ... ] ``` ## Parameters ***statement*** (Obligatoire) Instruction prise en charge PartiQL pour DynamoDB. La transaction entière doit être composée d’instructions de lecture ou d’instructions d’écriture. Vous ne pouvez pas mélanger les deux dans une seule transaction. ***parametertype*** (Facultatif) Type DynamoDB, si des paramètres ont été utilisés lors de la spécification de l’instruction PartiQL. ***parametervalue*** (Facultatif) Valeur de paramètre si des paramètres ont été utilisés lors de la spécification de l’instruction PartiQL. ## Valeurs renvoyées Cette instruction ne renvoie aucune valeur pour les opérations d’écriture (INSERT, UPDATE ou DELETE). Toutefois, elle renvoie différentes valeurs pour les opérations de lecture (SELECT) en fonction des conditions spécifiées dans la clause WHERE. **Note** Si l’une des opérations singleton INSERT, UPDATE ou DELETE renvoie une erreur, les transactions sont annulées avec l’exception `TransactionCanceledException`, et le code de motif d’annulation inclut les erreurs des opérations singleton individuelles. ## Exemples L’exemple suivant exécute plusieurs instructions sous forme de transaction. ------ #### [ AWS CLI ] 1. Enregistrez le code JSON suivant dans un fichier nommé partiql.json. ``` [ { "Statement": "EXISTS(SELECT * FROM \"Music\" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)" }, { "Statement": "INSERT INTO Music value {'Artist':?,'SongTitle':'?'}", "Parameters": [{\"S\": \"Acme Band\"}, {\"S\": \"Best Song\"}] }, { "Statement": "UPDATE \"Music\" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'" } ] ``` 1. Dans une invite de commande, exécutez la commande suivante. ``` aws dynamodb execute-transaction --transact-statements file://partiql.json ``` ------ #### [ Java ] ``` public class DynamoDBPartiqlTransaction { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2"); try { // Create ExecuteTransactionRequest ExecuteTransactionRequest executeTransactionRequest = createExecuteTransactionRequest(); ExecuteTransactionResult executeTransactionResult = dynamoDB.executeTransaction(executeTransactionRequest); System.out.println("ExecuteTransaction successful."); // Handle executeTransactionResult } catch (Exception e) { handleExecuteTransactionErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static ExecuteTransactionRequest createExecuteTransactionRequest() { ExecuteTransactionRequest request = new ExecuteTransactionRequest(); // Create statements List statements = getPartiQLTransactionStatements(); request.setTransactStatements(statements); return request; } private static List getPartiQLTransactionStatements() { List statements = new ArrayList(); statements.add(new ParameterizedStatement() .withStatement("EXISTS(SELECT * FROM "Music" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)")); statements.add(new ParameterizedStatement() .withStatement("INSERT INTO "Music" value {'Artist':'?','SongTitle':'?'}") .withParameters(new AttributeValue("Acme Band"),new AttributeValue("Best Song"))); statements.add(new ParameterizedStatement() .withStatement("UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'")); return statements; } // Handles errors during ExecuteTransaction execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleExecuteTransactionErrors(Exception exception) { try { throw exception; } catch (TransactionCanceledException tce) { System.out.println("Transaction Cancelled, implies a client issue, fix before retrying. Error: " + tce.getErrorMessage()); } catch (TransactionInProgressException tipe) { System.out.println("The transaction with the given request token is already in progress, consider changing " + "retry strategy for this type of error. Error: " + tipe.getErrorMessage()); } catch (IdempotentParameterMismatchException ipme) { System.out.println("Request rejected because it was retried with a different payload but with a request token that was already used, " + "change request token for this payload to be accepted. Error: " + ipme.getErrorMessage()); } catch (Exception e) { handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ L’exemple suivant montre les différentes valeurs renvoyées lorsque DynamoDB lit des éléments avec des conditions différentes spécifiées dans la clause WHERE. ------ #### [ AWS CLI ] 1. Enregistrez le code JSON suivant dans un fichier nommé partiql.json. ``` [ // Item exists and projected attribute exists { "Statement": "SELECT * FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'" }, // Item exists but projected attributes do not exist { "Statement": "SELECT non_existent_projected_attribute FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'" }, // Item does not exist { "Statement": "SELECT * FROM "Music" WHERE Artist='No One I Know' and SongTitle='Call You Today'" } ] ``` 1. commande suivante, dans une invite de commande. ``` aws dynamodb execute-transaction --transact-statements file://partiql.json ``` 1. La réponse suivante est renvoyée : ``` { "Responses": [ // Item exists and projected attribute exists { "Item": { "Artist":{ "S": "No One You Know" }, "SongTitle":{ "S": "Call Me Today" } } }, // Item exists but projected attributes do not exist { "Item": {} }, // Item does not exist {} ] } ``` ------ # Exécution d’opérations par lot avec PartiQL pour DynamoDB Cette section décrit comment utiliser des opérations par lot avec PartiQL pour DynamoDB. **Note** Le lot entier doit être composé d'instructions de lecture ou d'instructions d'écriture. Vous ne pouvez pas mélanger les deux dans une seule opération par lot. `BatchExecuteStatement` et `BatchWriteItem` ne peuvent pas exécuter plus de 25 instructions par lot. `BatchExecuteStatement` utilise `BatchGetItem` ce qui prend une liste de clés primaires dans des instructions séparées. **Topics** + [Syntaxe](#ql-reference.multiplestatements.batching.syntax) + [Parameters](#ql-reference.multiplestatements.batching.parameters) + [Exemples](#ql-reference.multiplestatements.batching.examples) ## Syntaxe ``` [ { "Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#9StkWHYTxm7x2AqSXcrfu7' AND sk = 'info'" }, { "Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#isC2ChceGbxHgESc4szoTE' AND sk = 'info'" } ] ``` ``` [ { "Statement":" statement ", "Parameters":[ { " parametertype " : " parametervalue " }, ...] } , ... ] ``` ## Parameters ***statement*** (Obligatoire) Instruction prise en charge PartiQL pour DynamoDB. + Le lot entier doit être composé d'instructions de lecture ou d'instructions d'écriture. Vous ne pouvez pas mélanger les deux dans une seule opération par lot. + `BatchExecuteStatement` et `BatchWriteItem` ne peuvent pas exécuter plus de 25 instructions par lot. ***parametertype*** (Facultatif) Type DynamoDB, si des paramètres ont été utilisés lors de la spécification de l’instruction PartiQL. ***parametervalue*** (Facultatif) Valeur de paramètre si des paramètres ont été utilisés lors de la spécification de l’instruction PartiQL. ## Exemples ------ #### [ AWS CLI ] 1. Enregistrez le JSON suivant dans un fichier nommé partiql.json ``` [ { "Statement": "INSERT INTO Music VALUE {'Artist':?,'SongTitle':?}", "Parameters": [{"S": "Acme Band"}, {"S": "Best Song"}] }, { "Statement": "UPDATE Music SET AwardsWon=1, AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" } ] ``` 1. Dans une invite de commande, exécutez la commande suivante. ``` aws dynamodb batch-execute-statement --statements file://partiql.json ``` ------ #### [ Java ] ``` public class DynamoDBPartiqlBatch { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2"); try { // Create BatchExecuteStatementRequest BatchExecuteStatementRequest batchExecuteStatementRequest = createBatchExecuteStatementRequest(); BatchExecuteStatementResult batchExecuteStatementResult = dynamoDB.batchExecuteStatement(batchExecuteStatementRequest); System.out.println("BatchExecuteStatement successful."); // Handle batchExecuteStatementResult } catch (Exception e) { handleBatchExecuteStatementErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static BatchExecuteStatementRequest createBatchExecuteStatementRequest() { BatchExecuteStatementRequest request = new BatchExecuteStatementRequest(); // Create statements List statements = getPartiQLBatchStatements(); request.setStatements(statements); return request; } private static List getPartiQLBatchStatements() { List statements = new ArrayList(); statements.add(new BatchStatementRequest() .withStatement("INSERT INTO Music value {'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}")); statements.add(new BatchStatementRequest() .withStatement("UPDATE Music set AwardDetail.BillBoard=[2020] where Artist='Acme Band' and SongTitle='PartiQL Rocks'")); return statements; } // Handles errors during BatchExecuteStatement execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleBatchExecuteStatementErrors(Exception exception) { try { throw exception; } catch (Exception e) { // There are no API specific errors to handle for BatchExecuteStatement, common DynamoDB API errors are handled below handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ # Politiques de sécurité IAM avec PartiQL pour DynamoDB Les autorisations suivantes sont requises : + Pour lire des éléments à l’aide de PartiQL pour DynamoDB, vous devez disposer de l’autorisation `dynamodb:PartiQLSelect` sur la table ou l’index. + Pour insérer des éléments à l’aide de PartiQL pour DynamoDB, vous devez disposer de l’autorisation `dynamodb:PartiQLInsert` sur la table ou l’index. + Pour mettre à jour des éléments à l’aide de PartiQL pour DynamoDB, vous devez disposer de l’autorisation `dynamodb:PartiQLUpdate` sur la table ou l’index. + Pour supprimer des éléments à l’aide de PartiQL pour DynamoDB, vous devez disposer de l’autorisation `dynamodb:PartiQLDelete` sur la table ou l’index. ## Exemple : autoriser toutes les instructions PartiQL pour DynamoDB () sur une table Select/Insert/Update/Delete La politique IAM suivante accorde les autorisations nécessaires pour exécuter toutes les instructions PartiQL pour DynamoDB sur une table. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Exemple : Autoriser les instructions PartiQL select pour DynamoDB sur une table La politique IAM suivante accorde les autorisations nécessaires pour exécuter l’instruction `select` sur une table spécifique. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Exemple : Autoriser les instructions PartiQL insert pour DynamoDB sur un index La politique IAM suivante accorde les autorisations nécessaires pour exécuter l’instruction `insert` sur un index spécifique. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music/index/index1" ] } ] } ``` ------ ## Exemple : Autoriser les instructions transactionnelles PartiQL pour DynamoDB sur une table La politique IAM suivante accorde les autorisations nécessaires pour exécuter uniquement des instructions transactionnelles sur une table spécifique. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ], "Condition":{ "StringEquals":{ "dynamodb:EnclosingOperation":[ "ExecuteTransaction" ] } } } ] } ``` ------ ## Exemple : Autoriser les lectures et d’écritures non transactionnelles PartiQL pour DynamoDB, et bloquer les instructions de lectures et d’écritures transactionnelles PartiQL sur une table. La politique IAM suivante accorde des autorisations pour exécuter des lectures et des écritures non transactionnelles PartiQL pour DynamoDB tout en bloquant les lectures et écritures transactionnelles PartiQL pour DynamoDB. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Deny", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ], "Condition":{ "StringEquals":{ "dynamodb:EnclosingOperation":[ "ExecuteTransaction" ] } } }, { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Exemple : autoriser les instructions de sélection et rejeter les instructions d’analyse de table complète dans PartiQL pour DynamoDB La politique IAM suivante accorde des autorisations pour exécuter l’instruction `select` sur une table spécifique tout en bloquant les instructions `select` qui entraînent une analyse de table complète. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Deny", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/WatchList" ], "Condition":{ "Bool":{ "dynamodb:FullTableScan":[ "true" ] } } }, { "Effect":"Allow", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/WatchList" ] } ] } ``` ------