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. # pilote Amazon QLDB pour Java **Important** Avis de fin de support : les clients existants pourront utiliser Amazon QLDB jusqu'à la fin du support le 31 juillet 2025. Pour plus de détails, consultez [Migrer un registre Amazon QLDB vers Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/). Pour utiliser les données de votre registre, vous pouvez vous connecter à Amazon QLDB depuis votre application Java à l'aide d'un pilote fourni. AWS Les rubriques suivantes décrivent comment démarrer avec le pilote QLDB pour Java. **Topics** + [ ## Ressources pour les conducteurs ](#getting-started.java.resources) + [ ## Prérequis ](#getting-started.java.prereqs) + [ ## Configuration de vos AWS informations d'identification par défaut et de votre région ](#getting-started.java.credentials) + [ ## Installation ](#getting-started.java.install) + [Tutoriel de démarrage rapide](driver-quickstart-java.md) + [Référence de livre de cuisine](driver-cookbook-java.md) ## Ressources pour les conducteurs Pour plus d'informations sur les fonctionnalités prises en charge par le pilote Java, consultez les ressources suivantes : + [Référence d'API : [2.x, 1.x](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/)](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/1.1.0/index.html) + [Code source du pilote (GitHub)](https://github.com/awslabs/amazon-qldb-driver-java) + [Exemple de code source d'application (GitHub)](https://github.com/aws-samples/amazon-qldb-dmv-sample-java) + [Framework Ledger Loader () GitHub](https://github.com/awslabs/amazon-qldb-ledger-load-java) + [Exemples de code Amazon Ion](ion.code-examples.md) ## Prérequis Avant de commencer à utiliser le pilote QLDB pour Java, vous devez effectuer les opérations suivantes : 1. Suivez les instructions AWS de configuration indiquées dans[Accès à Amazon QLDB](accessing.md). Cela inclut les éléments suivants : 1. Inscrivez-vous pour AWS. 1. Créez un utilisateur doté des autorisations QLDB appropriées. 1. Accordez un accès programmatique pour le développement. 1. Configurez un environnement de développement Java en téléchargeant et en installant les éléments suivants : 1. Kit de développement Java SE 8, tel qu'[Amazon Corretto](https://docs.aws.amazon.com/corretto/latest/corretto-8-ug/downloads-list.html) 8. 1. (Facultatif) Environnement de développement intégré (IDE) Java de votre choix, tel qu'[Eclipse](http://www.eclipse.org) ou [IntelliJ](https://www.jetbrains.com/idea/). 1. Configurez votre environnement de développement pour le AWS SDK pour Java by[Configuration de vos AWS informations d'identification par défaut et de votre région](#getting-started.java.credentials). Ensuite, vous pouvez télécharger l'exemple complet du didacticiel, ou vous pouvez installer uniquement le pilote dans un projet Java et exécuter des exemples de code abrégé. + Pour installer le pilote QLDB et AWS SDK pour Java le dans un projet existant, passez à. [Installation](#getting-started.java.install) + Pour configurer un projet et exécuter des exemples de codes abrégés illustrant les transactions de données de base sur un registre, consultez le[Tutoriel de démarrage rapide](driver-quickstart-java.md). + Pour obtenir des exemples plus détaillés des opérations relatives aux données et aux API de gestion dans l'exemple d'application complet du didacticiel, consultez le[Tutoriel Java](getting-started.java.tutorial.md). ## Configuration de vos AWS informations d'identification par défaut et de votre région Le pilote QLDB et le pilote [AWS SDK pour Java](https://aws.amazon.com/sdk-for-java)sous-jacent nécessitent que vous AWS fournissiez des informations d'identification à votre application lors de l'exécution. Les exemples de code présentés dans ce guide supposent que vous utilisez un fichier d' AWS informations d'identification, comme décrit dans la section [Définir les informations d'identification par défaut et la région](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials) dans le *guide du AWS SDK for Java 2.x développeur*. Dans le cadre de ces étapes, vous devez également définir votre point de terminaison QLDB par défaut Région AWS pour déterminer votre point de terminaison QLDB par défaut. Les exemples de code se connectent à QLDB par défaut. Région AWS Pour obtenir la liste complète des régions dans lesquelles QLDB est disponible, consultez la section Points de terminaison et quotas [Amazon QLDB](https://docs.aws.amazon.com/general/latest/gr/qldb.html) dans le. *Références générales AWS* Voici un exemple de fichier d' AWS informations d'identification nommé`~/.aws/credentials`, où le caractère tilde (`~`) représente votre répertoire personnel. ``` [default] aws_access_key_id = your_access_key_id aws_secret_access_key = your_secret_access_key ``` Remplacez les valeurs *your\$1access\$1key\$1id* et par vos propres AWS informations d'identification*your\$1secret\$1access\$1key*. ## Installation QLDB prend en charge les versions de pilotes Java suivantes et AWS leurs dépendances avec le SDK. **** | Versions du pilote | AWS SDK | Statut | Date de sortie la plus récente | | --- | --- | --- | --- | | [1. x](https://search.maven.org/artifact/software.amazon.qldb/amazon-qldb-driver-java/1.1.0/jar) | AWS SDK pour Java 1. x | Communiqué de production | 20 mars 2020 | | [2. x](https://search.maven.org/artifact/software.amazon.qldb/amazon-qldb-driver-java/2.3.1/jar) | AWS SDK for Java 2.x | Communiqué de production | 4 juin 2021 | Pour installer le pilote QLDB, nous vous recommandons d'utiliser un système de gestion des dépendances tel que Gradle ou Maven. Par exemple, ajoutez l'artefact suivant en tant que dépendance dans votre projet Java. ------ #### [ 2.x ] **Gradle** Ajoutez cette dépendance dans votre fichier `build.gradle` de configuration. ``` dependencies { compile group: 'software.amazon.qldb', name: 'amazon-qldb-driver-java', version: '2.3.1' } ``` **Maven** Ajoutez cette dépendance dans votre fichier `pom.xml` de configuration. ``` software.amazon.qldb amazon-qldb-driver-java 2.3.1 ``` Cet artefact inclut automatiquement le module AWS SDK for Java 2.x principal, les bibliothèques [Amazon Ion](ion.md) et les autres dépendances requises. ------ #### [ 1.x ] **Gradle** Ajoutez cette dépendance dans votre fichier `build.gradle` de configuration. ``` dependencies { compile group: 'software.amazon.qldb', name: 'amazon-qldb-driver-java', version: '1.1.0' } ``` **Maven** Ajoutez cette dépendance dans votre fichier `pom.xml` de configuration. ``` software.amazon.qldb amazon-qldb-driver-java 1.1.0 ``` Cet artefact inclut automatiquement le module AWS SDK pour Java principal, les bibliothèques [Amazon Ion](ion.md) et les autres dépendances requises. **Important** **Espace de noms Amazon Ion** : lorsque vous importez des classes Amazon Ion dans votre application, vous devez utiliser le package situé sous l'espace de noms`com.amazon.ion`. AWS SDK pour Java Cela dépend d'un autre package Ion situé sous l'espace de noms`software.amazon.ion`, mais il s'agit d'un package existant qui n'est pas compatible avec le pilote QLDB. ------ Pour des exemples de code abrégé expliquant comment exécuter des transactions de données de base sur un registre, consultez le[Référence de livre de cuisine](driver-cookbook-java.md). ### Autres bibliothèques facultatives Vous pouvez éventuellement ajouter les bibliothèques utiles suivantes dans votre projet. Ces artefacts sont des dépendances obligatoires dans l'[Tutoriel Java](getting-started.java.tutorial.md)exemple d'application. 1. [aws-java-sdk-qldb](https://search.maven.org/artifact/com.amazonaws/aws-java-sdk-qldb/1.11.785/jar)— Le module QLDB du. AWS SDK pour Java La version minimale de QLDB prise en charge est. `1.11.785` Utilisez ce module dans votre application pour interagir directement avec les opérations de l'API de gestion répertoriées dans le[Référence de l'API Amazon QLDB](api-reference.md). 1. [jackson-dataformat-ion](https://search.maven.org/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-ion/2.10.0/bundle)— Le module de format de données Jackson de FasterXML pour Ion. L'exemple d'application nécessite une version `2.10.0` ou une version ultérieure. ------ #### [ Gradle ] Ajoutez ces dépendances dans votre fichier `build.gradle` de configuration. ``` dependencies { compile group: 'com.amazonaws', name: 'aws-java-sdk-qldb', version: '1.11.785' compile group: 'com.fasterxml.jackson.dataformat', name: 'jackson-dataformat-ion', version: '2.10.0' } ``` ------ #### [ Maven ] Ajoutez ces dépendances dans votre fichier `pom.xml` de configuration. ``` com.amazonaws aws-java-sdk-qldb 1.11.785 com.fasterxml.jackson.dataformat jackson-dataformat-ion 2.10.0 ``` ------ # Pilote Amazon QLDB pour Java — Tutoriel de démarrage rapide **Important** Avis de fin de support : les clients existants pourront utiliser Amazon QLDB jusqu'à la fin du support le 31 juillet 2025. Pour plus de détails, consultez [Migrer un registre Amazon QLDB vers Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/). Dans ce didacticiel, vous apprendrez à configurer une application simple à l'aide de la dernière version du pilote Amazon QLDB pour Java. Ce guide inclut les étapes d'installation du pilote et des exemples de code abrégé des opérations de base de *création, de lecture, de mise à jour et de suppression* (CRUD). Pour des exemples plus détaillés illustrant ces opérations dans un exemple complet d'application, consultez le[Tutoriel Java](getting-started.java.tutorial.md). **Topics** + [ ## Prérequis ](#driver-quickstart-java.prereqs) + [ ## Étape 1 : Configurer votre projet ](#driver-quickstart-java.step-1) + [ ## Étape 2 : Initialisation du pilote ](#driver-quickstart-java.step-2) + [ ## Étape 3 : Création d'une table et d'un index ](#driver-quickstart-java.step-3) + [ ## Étape 4 : Insérer un document ](#driver-quickstart-java.step-4) + [ ## Étape 5 : Interrogez le document ](#driver-quickstart-java.step-5) + [ ## Étape 6 : Mettre à jour le document ](#driver-quickstart-java.step-6) + [ ## Exécution de l'application complète ](#driver-quickstart-java.complete) ## Prérequis Avant de commencer, assurez-vous d'effectuer les opérations suivantes : 1. Complétez le formulaire [Prérequis](getting-started.java.md#getting-started.java.prereqs) pour le pilote Java, si ce n'est déjà fait. Cela inclut l'inscription AWS, l'octroi d'un accès programmatique pour le développement et l'installation d'un environnement de développement intégré (IDE) Java. 1. Créez un registre nommé`quick-start`. Pour savoir comment créer un registre, voir [Opérations de base pour les registres Amazon QLDB](ledger-management.basics.md) ou [Étape 1 : Création d'un nouveau registre](getting-started-step-1.md) dans *Commencer à utiliser la console*. ## Étape 1 : Configurer votre projet Configurez d'abord votre projet Java. Nous vous recommandons d'utiliser le système de gestion des dépendances [Maven](https://maven.apache.org/index.html) pour ce didacticiel. **Note** Si vous utilisez un IDE doté de fonctionnalités permettant d'automatiser ces étapes de configuration, vous pouvez passer à[Étape 2 : Initialisation du pilote](#driver-quickstart-java.step-2). 1. Créez un dossier pour votre application. ``` $ mkdir myproject $ cd myproject ``` 1. Entrez la commande suivante pour initialiser votre projet à partir d'un modèle Maven. Remplacez *project-package**project-name*, et *maven-template* par vos propres valeurs, le cas échéant. ``` $ mvn archetype:generate -DgroupId=project-package \ -DartifactId=project-name \ -DarchetypeArtifactId=maven-template \ -DinteractiveMode=false ``` Pour *maven-template* cela, vous pouvez utiliser le modèle Maven de base : `maven-archetype-quickstart` 1. Pour ajouter le [pilote QLDB pour](https://search.maven.org/artifact/software.amazon.qldb/amazon-qldb-driver-java/2.3.1/jar) Java en tant que dépendance du projet, accédez au fichier que vous venez de `pom.xml` créer et ajoutez l'artefact suivant. ``` software.amazon.qldb amazon-qldb-driver-java 2.3.1 ``` Cet artefact inclut automatiquement le module [AWS SDK for Java 2.x](https://aws.amazon.com/sdk-for-java)principal, les bibliothèques [Amazon Ion](ion.md) et les autres dépendances requises. Votre `pom.xml` fichier doit maintenant ressembler à ce qui suit. ``` 4.0.0 software.amazon.qldb qldb-quickstart jar 1.0-SNAPSHOT qldb-quickstart http://maven.apache.org junit junit 3.8.1 test software.amazon.qldb amazon-qldb-driver-java 2.3.1 ``` 1. Ouvrez le fichier `App.java`. Ajoutez ensuite progressivement les exemples de code dans les étapes suivantes pour essayer certaines opérations CRUD de base. Vous pouvez également ignorer le step-by-step didacticiel et exécuter l'[application complète](#driver-quickstart-java.complete) à la place. ## Étape 2 : Initialisation du pilote Initialisez une instance du pilote qui se connecte au registre nommé. `quick-start` Ajoutez le code suivant à votre `App.java` fichier. ``` import java.util.*; import com.amazon.ion.*; import com.amazon.ion.system.*; import software.amazon.awssdk.services.qldbsession.QldbSessionClient; import software.amazon.qldb.*; public final class App { public static IonSystem ionSys = IonSystemBuilder.standard().build(); public static QldbDriver qldbDriver; public static void main(final String... args) { System.out.println("Initializing the driver"); qldbDriver = QldbDriver.builder() .ledger("quick-start") .transactionRetryPolicy(RetryPolicy .builder() .maxRetries(3) .build()) .sessionClientBuilder(QldbSessionClient.builder()) .build(); } } ``` ## Étape 3 : Création d'une table et d'un index L'exemple de code suivant montre comment exécuter `CREATE TABLE` des `CREATE INDEX` instructions. Dans la `main` méthode, ajoutez le code suivant qui crée une table nommée `People` et un index pour le `lastName` champ de cette table. Les [index](ql-reference.create-index.md) sont nécessaires pour optimiser les performances des requêtes et aider à limiter les exceptions de conflit liées au [contrôle optimiste de la simultanéité (OCC).](concurrency.md) ``` // Create a table and an index in the same transaction qldbDriver.execute(txn -> { System.out.println("Creating a table and an index"); txn.execute("CREATE TABLE People"); txn.execute("CREATE INDEX ON People(lastName)"); }); ``` ## Étape 4 : Insérer un document L'exemple de code suivant montre comment exécuter une `INSERT` instruction. QLDB prend en charge le langage de requête [partiQL](ql-reference.md) (compatible SQL) et le format de données [Amazon](ion.md) Ion (surensemble de JSON). Ajoutez le code suivant qui insère un document dans le `People` tableau. ``` // Insert a document qldbDriver.execute(txn -> { System.out.println("Inserting a document"); IonStruct person = ionSys.newEmptyStruct(); person.put("firstName").newString("John"); person.put("lastName").newString("Doe"); person.put("age").newInt(32); txn.execute("INSERT INTO People ?", person); }); ``` Cet exemple utilise un point d'interrogation (`?`) comme espace réservé aux variables pour transmettre les informations du document à l'instruction. Lorsque vous utilisez des espaces réservés, vous devez transmettre une valeur de type`IonValue`. **Astuce** Pour insérer plusieurs documents à l'aide d'une seule [INSERT](ql-reference.insert.md) instruction, vous pouvez transmettre un paramètre de type [IonList](driver-working-with-ion.md#driver-ion-list)(explicitement converti en tant que`IonValue`) à l'instruction comme suit. ``` // people is an IonList explicitly cast as an IonValue txn.execute("INSERT INTO People ?", (IonValue) people); ``` Vous ne placez pas la variable placeholder (`?`) entre crochets (`<<...>>`) lorsque vous passez un. `IonList` *Dans les instructions partiQL manuelles, les crochets à double angle indiquent une collection non ordonnée appelée sac.* ## Étape 5 : Interrogez le document L'exemple de code suivant montre comment exécuter une `SELECT` instruction. Ajoutez le code suivant qui interroge un document à partir de la `People` table. ``` // Query the document qldbDriver.execute(txn -> { System.out.println("Querying the table"); Result result = txn.execute("SELECT * FROM People WHERE lastName = ?", ionSys.newString("Doe")); IonStruct person = (IonStruct) result.iterator().next(); System.out.println(person.get("firstName")); // prints John System.out.println(person.get("lastName")); // prints Doe System.out.println(person.get("age")); // prints 32 }); ``` ## Étape 6 : Mettre à jour le document L'exemple de code suivant montre comment exécuter une `UPDATE` instruction. 1. Ajoutez le code suivant qui met à jour un document du `People` tableau en le mettant à jour `age` vers`42`. ``` // Update the document qldbDriver.execute(txn -> { System.out.println("Updating the document"); final List parameters = new ArrayList<>(); parameters.add(ionSys.newInt(42)); parameters.add(ionSys.newString("Doe")); txn.execute("UPDATE People SET age = ? WHERE lastName = ?", parameters); }); ``` 1. Interrogez à nouveau le document pour voir la valeur mise à jour. ``` // Query the updated document qldbDriver.execute(txn -> { System.out.println("Querying the table for the updated document"); Result result = txn.execute("SELECT * FROM People WHERE lastName = ?", ionSys.newString("Doe")); IonStruct person = (IonStruct) result.iterator().next(); System.out.println(person.get("firstName")); // prints John System.out.println(person.get("lastName")); // prints Doe System.out.println(person.get("age")); // prints 32 }); ``` 1. Utilisez Maven ou votre IDE pour compiler et exécuter le `App.java` fichier. ## Exécution de l'application complète L'exemple de code suivant représente la version complète de l'`App.java`application. Au lieu d'effectuer les étapes précédentes individuellement, vous pouvez également copier et exécuter cet exemple de code du début à la fin. Cette application montre certaines opérations CRUD de base sur le registre nommé. `quick-start` **Note** Avant d'exécuter ce code, assurez-vous qu'aucune table active n'est déjà nommée `People` dans le `quick-start` registre. Sur la première ligne, remplacez *project-package* par la `groupId` valeur que vous avez utilisée pour la commande Maven dans[Étape 1 : Configurer votre projet](#driver-quickstart-java.step-1). ``` package project-package; import java.util.*; import com.amazon.ion.*; import com.amazon.ion.system.*; import software.amazon.awssdk.services.qldbsession.QldbSessionClient; import software.amazon.qldb.*; public class App { public static IonSystem ionSys = IonSystemBuilder.standard().build(); public static QldbDriver qldbDriver; public static void main(final String... args) { System.out.println("Initializing the driver"); qldbDriver = QldbDriver.builder() .ledger("quick-start") .transactionRetryPolicy(RetryPolicy .builder() .maxRetries(3) .build()) .sessionClientBuilder(QldbSessionClient.builder()) .build(); // Create a table and an index in the same transaction qldbDriver.execute(txn -> { System.out.println("Creating a table and an index"); txn.execute("CREATE TABLE People"); txn.execute("CREATE INDEX ON People(lastName)"); }); // Insert a document qldbDriver.execute(txn -> { System.out.println("Inserting a document"); IonStruct person = ionSys.newEmptyStruct(); person.put("firstName").newString("John"); person.put("lastName").newString("Doe"); person.put("age").newInt(32); txn.execute("INSERT INTO People ?", person); }); // Query the document qldbDriver.execute(txn -> { System.out.println("Querying the table"); Result result = txn.execute("SELECT * FROM People WHERE lastName = ?", ionSys.newString("Doe")); IonStruct person = (IonStruct) result.iterator().next(); System.out.println(person.get("firstName")); // prints John System.out.println(person.get("lastName")); // prints Doe System.out.println(person.get("age")); // prints 32 }); // Update the document qldbDriver.execute(txn -> { System.out.println("Updating the document"); final List parameters = new ArrayList<>(); parameters.add(ionSys.newInt(42)); parameters.add(ionSys.newString("Doe")); txn.execute("UPDATE People SET age = ? WHERE lastName = ?", parameters); }); // Query the updated document qldbDriver.execute(txn -> { System.out.println("Querying the table for the updated document"); Result result = txn.execute("SELECT * FROM People WHERE lastName = ?", ionSys.newString("Doe")); IonStruct person = (IonStruct) result.iterator().next(); System.out.println(person.get("firstName")); // prints John System.out.println(person.get("lastName")); // prints Doe System.out.println(person.get("age")); // prints 42 }); } } ``` Utilisez Maven ou votre IDE pour compiler et exécuter le `App.java` fichier. # Pilote Amazon QLDB pour Java — Guide de référence du livre de recettes **Important** Avis de fin de support : les clients existants pourront utiliser Amazon QLDB jusqu'à la fin du support le 31 juillet 2025. Pour plus de détails, consultez [Migrer un registre Amazon QLDB vers Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/). Ce guide de référence présente les cas d'utilisation courants du pilote Amazon QLDB pour Java. Il fournit des exemples de code Java qui montrent comment utiliser le pilote pour exécuter des opérations de base de *création, de lecture, de mise à jour et de suppression* (CRUD). Il inclut également des exemples de code pour le traitement des données Amazon Ion. En outre, ce guide met en évidence les meilleures pratiques pour rendre les transactions idempotentes et mettre en œuvre des contraintes d'unicité. **Note** Le cas échéant, certains cas d'utilisation comportent des exemples de code différents pour chaque version majeure prise en charge du pilote QLDB pour Java. **Contents** + [ ## Importation du pilote ](#cookbook-java.importing) + [ ## Instanciation du pilote ](#cookbook-java.instantiating) + [ ## Opérations CRUD ](#cookbook-java.crud) + [ ### Création de tables ](#cookbook-java.crud.creating-tables) + [ ### Création d'index ](#cookbook-java.crud.creating-indexes) + [ ### Lecture de documents ](#cookbook-java.crud.reading) + [ ### Insertion de documents ](#cookbook-java.crud.inserting) + [ #### Insertion de plusieurs documents dans une seule déclaration ](#cookbook-java.crud.inserting.multiple) + [ ### Mettre à jour des documents ](#cookbook-java.crud.updating) + [ ### Supprimer des documents ](#cookbook-java.crud.deleting) + [ ### Exécution de plusieurs instructions dans une transaction ](#cookbook-java.crud.multi-statement) + [ ### Logique des nouvelles tentatives ](#cookbook-java.crud.retry-logic) + [ ### Mettre en œuvre des contraintes d'unicité ](#cookbook-java.crud.uniqueness-constraints) + [ ## Travailler avec Amazon Ion ](#cookbook-java.ion) + [ ### Importation des packages Ion ](#cookbook-java.ion.importing) + [ ### Initialisation d'Ion ](#cookbook-java.ion.initializing) + [ ### Création d'objets Ion ](#cookbook-java.ion.creating) + [ ### Lecture d'objets ioniques ](#cookbook-java.ion.reading) ## Importation du pilote L'exemple de code suivant importe le pilote, le client de session QLDB, les packages Amazon Ion et les autres dépendances associées. ------ #### [ 2.x ] ``` import com.amazon.ion.IonStruct; import com.amazon.ion.IonSystem; import com.amazon.ion.IonValue; import com.amazon.ion.system.IonSystemBuilder; import software.amazon.awssdk.services.qldbsession.QldbSessionClient; import software.amazon.qldb.QldbDriver; import software.amazon.qldb.Result; ``` ------ #### [ 1.x ] ``` import com.amazon.ion.IonStruct; import com.amazon.ion.IonSystem; import com.amazon.ion.IonValue; import com.amazon.ion.system.IonSystemBuilder; import com.amazonaws.services.qldbsession.AmazonQLDBSessionClientBuilder; import software.amazon.qldb.PooledQldbDriver; import software.amazon.qldb.Result; ``` ------ ## Instanciation du pilote L'exemple de code suivant crée une instance de pilote qui se connecte à un nom de registre spécifié et utilise la [logique de nouvelles tentatives](#cookbook-java.crud.retry-logic) spécifiée avec une limite de nouvelles tentatives personnalisée. **Note** Cet exemple instancie également un objet système Amazon Ion ()`IonSystem`. Vous avez besoin de cet objet pour traiter les données ioniques lors de l'exécution de certaines opérations de données dans cette référence. Pour en savoir plus, consultez [Travailler avec Amazon Ion](#cookbook-java.ion). ------ #### [ 2.x ] ``` QldbDriver qldbDriver = QldbDriver.builder() .ledger("vehicle-registration") .transactionRetryPolicy(RetryPolicy .builder() .maxRetries(3) .build()) .sessionClientBuilder(QldbSessionClient.builder()) .build(); IonSystem SYSTEM = IonSystemBuilder.standard().build(); ``` ------ #### [ 1.x ] ``` PooledQldbDriver qldbDriver = PooledQldbDriver.builder() .withLedger("vehicle-registration") .withRetryLimit(3) .withSessionClientBuilder(AmazonQLDBSessionClientBuilder.standard()) .build(); IonSystem SYSTEM = IonSystemBuilder.standard().build(); ``` ------ ## Opérations CRUD QLDB *exécute des opérations de création, de lecture, de mise à jour et* de suppression (CRUD) dans le cadre d'une transaction. **Avertissement** La meilleure pratique consiste à rendre vos transactions d'écriture strictement idempotentes. **Rendre les transactions idempotentes** Nous vous recommandons de rendre les transactions d'écriture idempotentes afin d'éviter tout effet secondaire inattendu en cas de nouvelle tentative. Une transaction est *idempotente* si elle peut être exécutée plusieurs fois et produire des résultats identiques à chaque fois. Prenons l'exemple d'une transaction qui insère un document dans une table nommée`Person`. La transaction doit d'abord vérifier si le document existe déjà dans le tableau. Sans cette vérification, le tableau peut se retrouver avec des documents dupliqués. Supposons que QLDB valide correctement la transaction côté serveur, mais que le client expire en attendant une réponse. Si la transaction n'est pas idempotente, le même document peut être inséré plusieurs fois en cas de nouvelle tentative. **Utilisation d'index pour éviter l'analyse complète des tables** Nous vous recommandons également d'exécuter des instructions contenant une clause de `WHERE` prédicat à l'aide d'un opérateur d'*égalité* sur un champ indexé ou un identifiant de document ; par exemple, `WHERE indexedField = 123` ou. `WHERE indexedField IN (456, 789)` Sans cette recherche indexée, QLDB doit effectuer une analyse des tables, ce qui peut entraîner des délais d'expiration des transactions *ou des conflits de contrôle de simultanéité optimistes* (OCC). Pour plus d'informations sur l'OCC, consultez[Modèle de simultanéité Amazon QLDB](concurrency.md). **Transactions créées implicitement** La méthode [QldbDriver.execute](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/software/amazon/qldb/QldbDriver.html) accepte une fonction lambda qui reçoit une instance d'[Executor](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/software/amazon/qldb/Executor.html), que vous pouvez utiliser pour exécuter des instructions. L'`Executor`instance encapsule une transaction créée implicitement. Vous pouvez exécuter des instructions dans la fonction lambda à l'aide de la `Executor.execute` méthode. Le pilote valide implicitement la transaction lorsque la fonction lambda revient. Les sections suivantes montrent comment exécuter des opérations CRUD de base, spécifier une logique de nouvelle tentative personnalisée et implémenter des contraintes d'unicité. **Note** Le cas échéant, ces sections fournissent des exemples de code relatifs au traitement des données Amazon Ion à l'aide de la bibliothèque Ion intégrée et de la bibliothèque de mappage Jackson Ion. Pour en savoir plus, consultez [Travailler avec Amazon Ion](#cookbook-java.ion). **Contents** + [ ### Création de tables ](#cookbook-java.crud.creating-tables) + [ ### Création d'index ](#cookbook-java.crud.creating-indexes) + [ ### Lecture de documents ](#cookbook-java.crud.reading) + [ ### Insertion de documents ](#cookbook-java.crud.inserting) + [ #### Insertion de plusieurs documents dans une seule déclaration ](#cookbook-java.crud.inserting.multiple) + [ ### Mettre à jour des documents ](#cookbook-java.crud.updating) + [ ### Supprimer des documents ](#cookbook-java.crud.deleting) + [ ### Exécution de plusieurs instructions dans une transaction ](#cookbook-java.crud.multi-statement) + [ ### Logique des nouvelles tentatives ](#cookbook-java.crud.retry-logic) + [ ### Mettre en œuvre des contraintes d'unicité ](#cookbook-java.crud.uniqueness-constraints) ### Création de tables ``` qldbDriver.execute(txn -> { txn.execute("CREATE TABLE Person"); }); ``` ### Création d'index ``` qldbDriver.execute(txn -> { txn.execute("CREATE INDEX ON Person(GovId)"); }); ``` ### Lecture de documents ``` // Assumes that Person table has documents as follows: // { GovId: "TOYENC486FH", FirstName: "Brent" } qldbDriver.execute(txn -> { Result result = txn.execute("SELECT * FROM Person WHERE GovId = 'TOYENC486FH'"); IonStruct person = (IonStruct) result.iterator().next(); System.out.println(person.get("GovId")); // prints TOYENC486FH System.out.println(person.get("FirstName")); // prints Brent }); ``` **Utilisation des paramètres de requête** L'exemple de code suivant utilise un paramètre de requête de type Ion. ``` qldbDriver.execute(txn -> { Result result = txn.execute("SELECT * FROM Person WHERE GovId = ?", SYSTEM.newString("TOYENC486FH")); IonStruct person = (IonStruct) result.iterator().next(); System.out.println(person.get("GovId")); // prints TOYENC486FH System.out.println(person.get("FirstName")); // prints Brent }); ``` L'exemple de code suivant utilise plusieurs paramètres de requête. ``` qldbDriver.execute(txn -> { Result result = txn.execute("SELECT * FROM Person WHERE GovId = ? AND FirstName = ?", SYSTEM.newString("TOYENC486FH"), SYSTEM.newString("Brent")); IonStruct person = (IonStruct) result.iterator().next(); System.out.println(person.get("GovId")); // prints TOYENC486FH System.out.println(person.get("FirstName")); // prints Brent }); ``` L'exemple de code suivant utilise une liste de paramètres de requête. ``` qldbDriver.execute(txn -> { final List parameters = new ArrayList<>(); parameters.add(SYSTEM.newString("TOYENC486FH")); parameters.add(SYSTEM.newString("ROEE1")); parameters.add(SYSTEM.newString("YH844")); Result result = txn.execute("SELECT * FROM Person WHERE GovId IN (?,?,?)", parameters); IonStruct person = (IonStruct) result.iterator().next(); System.out.println(person.get("GovId")); // prints TOYENC486FH System.out.println(person.get("FirstName")); // prints Brent }); ``` #### Utilisation du mappeur Jackson ``` // Assumes that Person table has documents as follows: // {GovId: "TOYENC486FH", FirstName: "Brent" } qldbDriver.execute(txn -> { try { Result result = txn.execute("SELECT * FROM Person WHERE GovId = 'TOYENC486FH'"); Person person = MAPPER.readValue(result.iterator().next(), Person.class); System.out.println(person.getFirstName()); // prints Brent System.out.println(person.getGovId()); // prints TOYENC486FH } catch (IOException e) { e.printStackTrace(); } }); ``` **Utilisation des paramètres de requête** L'exemple de code suivant utilise un paramètre de requête de type Ion. ``` qldbDriver.execute(txn -> { try { Result result = txn.execute("SELECT * FROM Person WHERE GovId = ?", MAPPER.writeValueAsIonValue("TOYENC486FH")); Person person = MAPPER.readValue(result.iterator().next(), Person.class); System.out.println(person.getFirstName()); // prints Brent System.out.println(person.getGovId()); // prints TOYENC486FH } catch (IOException e) { e.printStackTrace(); } }); ``` L'exemple de code suivant utilise plusieurs paramètres de requête. ``` qldbDriver.execute(txn -> { try { Result result = txn.execute("SELECT * FROM Person WHERE GovId = ? AND FirstName = ?", MAPPER.writeValueAsIonValue("TOYENC486FH"), MAPPER.writeValueAsIonValue("Brent")); Person person = MAPPER.readValue(result.iterator().next(), Person.class); System.out.println(person.getFirstName()); // prints Brent System.out.println(person.getGovId()); // prints TOYENC486FH } catch (IOException e) { e.printStackTrace(); } }); ``` L'exemple de code suivant utilise une liste de paramètres de requête. ``` qldbDriver.execute(txn -> { try { final List parameters = new ArrayList<>(); parameters.add(MAPPER.writeValueAsIonValue("TOYENC486FH")); parameters.add(MAPPER.writeValueAsIonValue("ROEE1")); parameters.add(MAPPER.writeValueAsIonValue("YH844")); Result result = txn.execute("SELECT * FROM Person WHERE GovId IN (?,?,?)", parameters); Person person = MAPPER.readValue(result.iterator().next(), Person.class); System.out.println(person.getFirstName()); // prints Brent System.out.println(person.getGovId()); // prints TOYENC486FH } catch (IOException e) { e.printStackTrace(); } }); ``` **Note** Lorsque vous exécutez une requête sans recherche indexée, elle appelle une analyse complète de la table. Dans cet exemple, nous recommandons d'avoir un [index](ql-reference.create-index.md) sur le `GovId` terrain pour optimiser les performances. Si l'index n'est pas activé`GovId`, les requêtes peuvent avoir une latence plus importante et peuvent également entraîner des exceptions de conflit OCC ou des délais d'expiration des transactions. ### Insertion de documents L'exemple de code suivant insère les types de données Ion. ``` qldbDriver.execute(txn -> { // Check if a document with GovId:TOYENC486FH exists // This is critical to make this transaction idempotent Result result = txn.execute("SELECT * FROM Person WHERE GovId = ?", SYSTEM.newString("TOYENC486FH")); // Check if there is a result if (!result.iterator().hasNext()) { IonStruct person = SYSTEM.newEmptyStruct(); person.put("GovId").newString("TOYENC486FH"); person.put("FirstName").newString("Brent"); // Insert the document txn.execute("INSERT INTO Person ?", person); } }); ``` #### Utilisation du mappeur Jackson L'exemple de code suivant insère les types de données Ion. ``` qldbDriver.execute(txn -> { try { // Check if a document with GovId:TOYENC486FH exists // This is critical to make this transaction idempotent Result result = txn.execute("SELECT * FROM Person WHERE GovId = ?", MAPPER.writeValueAsIonValue("TOYENC486FH")); // Check if there is a result if (!result.iterator().hasNext()) { // Insert the document txn.execute("INSERT INTO Person ?", MAPPER.writeValueAsIonValue(new Person("Brent", "TOYENC486FH"))); } } catch (IOException e) { e.printStackTrace(); } }); ``` Cette transaction insère un document dans le `Person` tableau. Avant l'insertion, il vérifie d'abord si le document existe déjà dans le tableau. **Cette vérification rend la transaction idempotente par nature.** Même si vous exécutez cette transaction plusieurs fois, elle ne provoquera aucun effet secondaire involontaire. **Note** Dans cet exemple, nous recommandons d'avoir un index sur le `GovId` terrain pour optimiser les performances. Si l'index n'est pas activé`GovId`, les instructions peuvent avoir une latence plus importante et peuvent également entraîner des exceptions de conflit OCC ou des délais d'attente pour les transactions. #### Insertion de plusieurs documents dans une seule déclaration Pour insérer plusieurs documents à l'aide d'une seule [INSERT](ql-reference.insert.md) instruction, vous pouvez transmettre un paramètre de type [IonList](driver-working-with-ion.md#driver-ion-list)(explicitement converti en tant que`IonValue`) à l'instruction comme suit. ``` // people is an IonList explicitly cast as an IonValue txn.execute("INSERT INTO People ?", (IonValue) people); ``` Vous ne placez pas la variable placeholder (`?`) entre crochets (`<<...>>`) lorsque vous passez un. `IonList` *Dans les instructions partiQL manuelles, les crochets à double angle indiquent une collection non ordonnée appelée sac.* ##### Pourquoi le casting explicite est-il requis ? La méthode [TransactionExecutor.execute](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/software/amazon/qldb/TransactionExecutor.html) est surchargée. Il accepte un nombre variable d'`IonValue`arguments (*varargs*) ou un seul `List` argument. Dans [ion-java](https://www.javadoc.io/doc/com.amazon.ion/ion-java/latest/index.html), `IonList` est implémenté en tant que. `List` Java utilise par défaut l'implémentation de méthode la plus spécifique lorsque vous appelez une méthode surchargée. Dans ce cas, lorsque vous transmettez un `IonList` paramètre, il utilise par défaut la méthode qui prend un`List`. Lorsqu'elle est invoquée, cette implémentation de méthode transmet les `IonValue` éléments de la liste sous forme de valeurs distinctes. Ainsi, pour invoquer la méthode varargs à la place, vous devez explicitement convertir un `IonList` paramètre en. `IonValue` ### Mettre à jour des documents ``` qldbDriver.execute(txn -> { final List parameters = new ArrayList<>(); parameters.add(SYSTEM.newString("John")); parameters.add(SYSTEM.newString("TOYENC486FH")); txn.execute("UPDATE Person SET FirstName = ? WHERE GovId = ?", parameters); }); ``` #### Utilisation du mappeur Jackson ``` qldbDriver.execute(txn -> { try { final List parameters = new ArrayList<>(); parameters.add(MAPPER.writeValueAsIonValue("John")); parameters.add(MAPPER.writeValueAsIonValue("TOYENC486FH")); txn.execute("UPDATE Person SET FirstName = ? WHERE GovId = ?", parameters); } catch (IOException e) { e.printStackTrace(); } }); ``` **Note** Dans cet exemple, nous recommandons d'avoir un index sur le `GovId` terrain pour optimiser les performances. Si l'index n'est pas activé`GovId`, les instructions peuvent avoir une latence plus importante et peuvent également entraîner des exceptions de conflit OCC ou des délais d'attente pour les transactions. ### Supprimer des documents ``` qldbDriver.execute(txn -> { txn.execute("DELETE FROM Person WHERE GovId = ?", SYSTEM.newString("TOYENC486FH")); }); ``` #### Utilisation du mappeur Jackson ``` qldbDriver.execute(txn -> { try { txn.execute("DELETE FROM Person WHERE GovId = ?", MAPPER.writeValueAsIonValue("TOYENC486FH")); } catch (IOException e) { e.printStackTrace(); } }); ``` **Note** Dans cet exemple, nous recommandons d'avoir un index sur le `GovId` terrain pour optimiser les performances. Si l'index n'est pas activé`GovId`, les instructions peuvent avoir une latence plus importante et peuvent également entraîner des exceptions de conflit OCC ou des délais d'attente pour les transactions. ### Exécution de plusieurs instructions dans une transaction ``` // This code snippet is intentionally trivial. In reality you wouldn't do this because you'd // set your UPDATE to filter on vin and insured, and check if you updated something or not. public static boolean InsureCar(QldbDriver qldbDriver, final String vin) { final IonSystem ionSystem = IonSystemBuilder.standard().build(); final IonString ionVin = ionSystem.newString(vin); return qldbDriver.execute(txn -> { Result result = txn.execute( "SELECT insured FROM Vehicles WHERE vin = ? AND insured = FALSE", ionVin); if (!result.isEmpty()) { txn.execute("UPDATE Vehicles SET insured = TRUE WHERE vin = ?", ionVin); return true; } return false; }); } ``` ### Logique des nouvelles tentatives La `execute` méthode du pilote comporte un mécanisme de nouvelle tentative intégré qui tente à nouveau la transaction si une exception réessayable se produit (comme un délai d'expiration ou un conflit OCC). ------ #### [ 2.x ] Le nombre maximum de tentatives et la stratégie de temporisation sont configurables. La limite de nouvelles tentatives par défaut est`4`, et la stratégie de réduction par défaut est. [DefaultQldbTransactionBackoffStrategy](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/software/amazon/qldb/DefaultQldbTransactionBackoffStrategy.html) Vous pouvez définir la configuration des nouvelles tentatives par instance de pilote et également par transaction en utilisant une instance de [RetryPolicy](https://javadoc.io/doc/software.amazon.qldb/amazon-qldb-driver-java/latest/software/amazon/qldb/RetryPolicy.html). L'exemple de code suivant spécifie une logique de nouvelles tentatives avec une limite de tentatives personnalisée et une stratégie de temporisation personnalisée pour une instance du pilote. ``` public void retry() { QldbDriver qldbDriver = QldbDriver.builder() .ledger("vehicle-registration") .transactionRetryPolicy(RetryPolicy.builder() .maxRetries(2) .backoffStrategy(new CustomBackOffStrategy()).build()) .sessionClientBuilder(QldbSessionClient.builder()) .build(); } private class CustomBackOffStrategy implements BackoffStrategy { @Override public Duration calculateDelay(RetryPolicyContext retryPolicyContext) { return Duration.ofMillis(1000 * retryPolicyContext.retriesAttempted()); } } ``` L'exemple de code suivant spécifie une logique de nouvelles tentatives avec une limite de tentatives personnalisée et une stratégie de temporisation personnalisée pour une transaction particulière. Cette configuration `execute` remplace la logique de nouvelle tentative définie pour l'instance de pilote. ``` public void retry() { Result result = qldbDriver.execute(txn -> { txn.execute("SELECT * FROM Person WHERE GovId = ?", SYSTEM.newString("TOYENC486FH")); }, RetryPolicy.builder() .maxRetries(2) .backoffStrategy(new CustomBackOffStrategy()) .build()); } private class CustomBackOffStrategy implements BackoffStrategy { // Configuring a custom backoff which increases delay by 1s for each attempt. @Override public Duration calculateDelay(RetryPolicyContext retryPolicyContext) { return Duration.ofMillis(1000 * retryPolicyContext.retriesAttempted()); } } ``` ------ #### [ 1.x ] Le nombre maximum de tentatives de nouvelle tentative est configurable. Vous pouvez configurer la limite de tentatives en définissant la `retryLimit` propriété lors de l'initialisation`PooledQldbDriver`. La limite de nouvelles tentatives par défaut est `4` de. ------ ### Mettre en œuvre des contraintes d'unicité QLDB ne prend pas en charge les index uniques, mais vous pouvez implémenter ce comportement dans votre application. Supposons que vous souhaitiez implémenter une contrainte d'unicité sur le `GovId` champ de la `Person` table. Pour ce faire, vous pouvez écrire une transaction qui effectue les opérations suivantes : 1. Affirme que le tableau ne contient aucun document existant avec une valeur spécifiée`GovId`. 1. Insérez le document si l'assertion est acceptée. Si une transaction concurrente passe simultanément l'assertion, une seule des transactions sera validée avec succès. L'autre transaction échouera en raison d'une exception de conflit OCC. L'exemple de code suivant montre comment implémenter cette logique de contrainte d'unicité. ``` qldbDriver.execute(txn -> { Result result = txn.execute("SELECT * FROM Person WHERE GovId = ?", SYSTEM.newString("TOYENC486FH")); // Check if there is a result if (!result.iterator().hasNext()) { IonStruct person = SYSTEM.newEmptyStruct(); person.put("GovId").newString("TOYENC486FH"); person.put("FirstName").newString("Brent"); // Insert the document txn.execute("INSERT INTO Person ?", person); } }); ``` **Note** Dans cet exemple, nous recommandons d'avoir un index sur le `GovId` terrain pour optimiser les performances. Si l'index n'est pas activé`GovId`, les instructions peuvent avoir une latence plus importante et peuvent également entraîner des exceptions de conflit OCC ou des délais d'attente pour les transactions. ## Travailler avec Amazon Ion Il existe plusieurs méthodes pour traiter les données Amazon Ion dans QLDB. Vous pouvez utiliser les méthodes intégrées de la [bibliothèque Ion](https://github.com/amzn/ion-java) pour créer et modifier des documents de manière flexible selon vos besoins. Vous pouvez également utiliser le [module de format de données Jackson de FasterXML pour Ion afin de mapper](https://github.com/FasterXML/jackson-dataformats-binary/tree/master/ion) les documents Ion sur de *simples anciens modèles d'objets Java* (POJO). Les sections suivantes fournissent des exemples de code de traitement de données ioniques à l'aide des deux techniques. **Contents** + [ ### Importation des packages Ion ](#cookbook-java.ion.importing) + [ ### Initialisation d'Ion ](#cookbook-java.ion.initializing) + [ ### Création d'objets Ion ](#cookbook-java.ion.creating) + [ ### Lecture d'objets ioniques ](#cookbook-java.ion.reading) ### Importation des packages Ion Ajoutez l'artefact [ion-java en](https://search.maven.org/artifact/com.amazon.ion/ion-java/1.6.1/bundle) tant que dépendance dans votre projet Java. ------ #### [ Gradle ] ``` dependencies { compile group: 'com.amazon.ion', name: 'ion-java', version: '1.6.1' } ``` ------ #### [ Maven ] ``` com.amazon.ion ion-java 1.6.1 ``` ------ Importez les packages Ion suivants. ``` import com.amazon.ion.IonStruct; import com.amazon.ion.IonSystem; import com.amazon.ion.system.IonSystemBuilder; ``` #### Utilisation du mappeur Jackson Ajoutez l'artefact [jackson-dataformat-ion](https://search.maven.org/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-ion/2.10.0/bundle)en tant que dépendance dans votre projet Java. QLDB nécessite `2.10.0` une version ou une version ultérieure. ------ #### [ Gradle ] ``` dependencies { compile group: 'com.fasterxml.jackson.dataformat', name: 'jackson-dataformat-ion', version: '2.10.0' } ``` ------ #### [ Maven ] ``` com.fasterxml.jackson.dataformat jackson-dataformat-ion 2.10.0 ``` ------ Importez les packages Ion suivants. ``` import com.amazon.ion.IonReader; import com.amazon.ion.IonStruct; import com.amazon.ion.system.IonReaderBuilder; import com.amazon.ion.system.IonSystemBuilder; import com.fasterxml.jackson.dataformat.ion.IonObjectMapper; import com.fasterxml.jackson.dataformat.ion.ionvalue.IonValueMapper; ``` ### Initialisation d'Ion ``` IonSystem SYSTEM = IonSystemBuilder.standard().build(); ``` #### Utilisation du mappeur Jackson ``` IonObjectMapper MAPPER = new IonValueMapper(IonSystemBuilder.standard().build()); ``` ### Création d'objets Ion L'exemple de code suivant crée un objet Ion à l'aide de l'`IonStruct`interface et de ses méthodes intégrées. ``` IonStruct ionStruct = SYSTEM.newEmptyStruct(); ionStruct.put("GovId").newString("TOYENC486FH"); ionStruct.put("FirstName").newString("Brent"); System.out.println(ionStruct.toPrettyString()); // prints a nicely formatted copy of ionStruct ``` #### Utilisation du mappeur Jackson Supposons que vous disposiez d'une classe de modèle mappée en JSON nommée comme suit`Person`. ``` import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; public static class Person { private final String firstName; private final String govId; @JsonCreator public Person(@JsonProperty("FirstName") final String firstName, @JsonProperty("GovId") final String govId) { this.firstName = firstName; this.govId = govId; } @JsonProperty("FirstName") public String getFirstName() { return firstName; } @JsonProperty("GovId") public String getGovId() { return govId; } } ``` L'exemple de code suivant crée un `IonStruct` objet à partir d'une instance de`Person`. ``` IonStruct ionStruct = (IonStruct) MAPPER.writeValueAsIonValue(new Person("Brent", "TOYENC486FH")); ``` ### Lecture d'objets ioniques L'exemple de code suivant imprime chaque champ de l'`ionStruct`instance. ``` // ionStruct is an instance of IonStruct System.out.println(ionStruct.get("GovId")); // prints TOYENC486FH System.out.println(ionStruct.get("FirstName")); // prints Brent ``` #### Utilisation du mappeur Jackson L'exemple de code suivant lit un `IonStruct` objet et le met en correspondance avec une instance de`Person`. ``` // ionStruct is an instance of IonStruct IonReader reader = IonReaderBuilder.standard().build(ionStruct); Person person = MAPPER.readValue(reader, Person.class); System.out.println(person.getFirstName()); // prints Brent System.out.println(person.getGovId()); // prints TOYENC486FH ``` Pour plus d'informations sur l'utilisation d'Ion, consultez la [documentation Amazon Ion](http://amzn.github.io/ion-docs/) sur GitHub. Pour d'autres exemples de code relatifs à l'utilisation d'Ion dans QLDB, consultez. [Utilisation des types de données Amazon Ion dans Amazon QLDB](driver-working-with-ion.md)