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.
# Référence du format de données Amazon Ion dans Amazon QLDB
**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/).
[Amazon QLDB utilise un modèle de notation de données qui unifie [Amazon](http://amzn.github.io/ion-docs/) Ion avec un sous-ensemble de types partiQL.](https://partiql.org/) Cette section fournit un aperçu de référence du format de données des documents Ion, indépendamment de son intégration avec partiQL.
**Interroger Ion avec PartiQL dans Amazon QLDB**
*Pour connaître la syntaxe et la sémantique de l'interrogation de données Ion avec PartiQL dans QLDB, consultez la référence Amazon QLDB PartiQL. [Interroger Ion avec PartiQL](ql-reference.query.md)*
Pour des exemples de code qui interrogent et traitent des données Ion dans un registre QLDB, reportez-vous aux sections et. [Exemples de code Amazon Ion](ion.code-examples.md) [Travailler avec Amazon Ion](driver-working-with-ion.md)
**Topics**
+ [Qu'est-ce qu'Amazon Ion ?](#ion.summary)
+ [Spécification des ions](#ion.spec)
+ [Compatible avec JSON](#ion.json-compatible)
+ [Extensions depuis JSON](#ion.json-ext)
+ [Exemple de texte ionique](#ion.example)
+ [Références d'API](#ion.api-ref)
+ [Exemples de code Amazon Ion dans QLDB](ion.code-examples.md)
## Qu'est-ce qu'Amazon Ion ?
Ion est un format de sérialisation de données open source, richement typé, autodescriptif et hiérarchique qui a été initialement développé en interne chez Amazon. Il est basé sur un modèle de données abstrait qui vous permet de stocker des données structurées et non structurées. Il s'agit d'un sur-ensemble de JSON, ce qui signifie que tout document JSON valide est également un document Ion valide. Ce guide suppose une connaissance pratique de base de JSON. Si vous ne connaissez pas encore le JSON, consultez [Présentation du JSON](http://json.org) pour plus d'informations.
Vous pouvez noter les documents Ion de manière interchangeable sous forme de texte lisible par l'homme ou sous forme codée en binaire. Comme le JSON, le formulaire de texte est facile à lire et à écrire, ce qui permet un prototypage rapide. Le codage binaire est plus compact et plus efficace pour la persistance, la transmission et l'analyse. Un processeur Ion peut transcoder entre les deux formats pour représenter exactement le même ensemble de structures de données sans aucune perte de données. Cette fonctionnalité permet aux applications d'optimiser la façon dont elles traitent les données pour différents cas d'utilisation.
**Note**
Le modèle de données Ion est strictement basé sur des valeurs et ne prend pas en charge les références. Ainsi, le modèle de données peut représenter des hiérarchies de données imbriquées à une profondeur arbitraire, mais pas des graphes orientés.
## Spécification des ions
Pour obtenir la liste complète des types de données Ion Core avec des descriptions complètes et des détails sur le formatage des valeurs, consultez le [document de spécification Ion](http://amzn.github.io/ion-docs/docs/spec.html) sur le GitHub site Amazon.
Pour rationaliser le développement des applications, Amazon Ion fournit des bibliothèques clientes qui traitent les données Ion pour vous. Pour des exemples de code illustrant des cas d'utilisation courants pour le traitement des données ioniques, consultez le [livre de recettes Amazon Ion](http://amzn.github.io/ion-docs/guides/cookbook.html) sur GitHub.
## Compatible avec JSON
Comme dans le JSON, vous composez des documents Amazon Ion avec un ensemble de types de données primitifs et un ensemble de types de conteneurs définis de manière récursive. Ion inclut les types de données JSON traditionnels suivants :
+ `null`: valeur nulle (vide) générique non typée. De plus, comme décrit dans la section suivante, Ion prend en charge un type nul distinct pour chaque type primitif.
+ `bool`: valeurs booléennes.
+ `string`: littéraux de texte Unicode.
+ `list`: collections de valeurs hétérogènes ordonnées.
+ `struct`: collections non ordonnées de paires nom-valeur. Comme JSON, il `struct` autorise plusieurs valeurs par nom, mais cela est généralement déconseillé.
## Extensions depuis JSON
### Types de numéros
Au lieu du `number` type JSON ambigu, Amazon Ion définit strictement les nombres comme l'un des types suivants :
+ `int`: entiers signés de taille arbitraire.
+ `decimal`: nombres réels codés en décimal d'une précision arbitraire.
+ `float`: nombres à virgule flottante codés en binaire (IEEE 64 bits).
Lors de l'analyse de documents, un processeur ionique attribue les types de numéros suivants :
+ `int`: nombres sans exposant ni point décimal (par exemple,`100200`).
+ `decimal`: nombres avec un point décimal et sans exposant (par exemple`0.00001`,`200.0`).
+ `float`: nombres avec exposant, tels que la notation scientifique ou la notation E (par exemple`2e0`,`3.1e-4`).
### Nouveaux types de données
Amazon Ion ajoute les types de données suivants :
+ `timestamp`: Date/time/timezone moments de précision arbitraire.
+ `symbol`: Atomes symboliques Unicode (tels que les identifiants).
+ `blob`: données binaires de codage défini par l'utilisateur.
+ `clob`: données de texte dont le codage est défini par l'utilisateur.
+ `sexp`: collections ordonnées de valeurs avec une sémantique définie par l'application.
### Types nuls
Outre le type nul générique défini par JSON, Amazon Ion prend en charge un type nul distinct pour chaque type primitif. Cela indique un manque de valeur tout en conservant un type de données strict.
```
null
null.null // Identical to untyped null
null.bool
null.int
null.float
null.decimal
null.timestamp
null.string
null.symbol
null.blob
null.clob
null.struct
null.list
null.sexp
```
## Exemple de texte ionique
```
// Here is a struct, which is similar to a JSON object.
{
// Field names don't always have to be quoted.
name: "fido",
// This is an integer.
age: 7,
// This is a timestamp with day precision.
birthday: 2012-03-01T,
// Here is a list, which is like a JSON array.
toys: [
// These are symbol values, which are like strings,
// but get encoded as integers in binary.
ball,
rope
],
}
```
## Références d'API
+ [ion-go](https://pkg.go.dev/github.com/amzn/ion-go/ion)
+ [ion-java](https://www.javadoc.io/doc/com.amazon.ion/ion-java/latest/index.html)
+ [ion-js](https://amazon-ion.github.io/ion-js/api/)
+ [ion-python](https://ion-python.readthedocs.io/en/latest/)
# Exemples de code Amazon Ion dans QLDB
**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/).
Cette section fournit des exemples de code qui traitent les données Amazon Ion en lisant et en écrivant les valeurs des documents dans un registre Amazon QLDB. Les exemples de code utilisent le pilote QLDB pour exécuter des instructions partiQL sur le registre. Ces exemples font partie de l'exemple d'application et sont open source sur le [ GitHub site AWS Samples](https://github.com/aws-samples/?q=qldb). [Démarrer avec Amazon QLDB à l'aide d'un exemple de didacticiel d'application](getting-started-sample-app.md)
Pour des exemples de code généraux illustrant les cas d'utilisation courants du traitement des données ioniques, consultez le [livre de recettes Amazon Ion](http://amzn.github.io/ion-docs/guides/cookbook.html) sur GitHub.
## Exécution du code
Le code du didacticiel pour chaque langage de programmation effectue les étapes suivantes :
1. Connectez-vous au registre `vehicle-registration` d'échantillons.
1. Créez une table nommée`IonTypes`.
1. Insérez un document dans le tableau avec un seul `Name` champ.
1. Pour chaque [type de données Ion](http://amzn.github.io/ion-docs/docs/spec.html) pris en charge :
1. Mettez à jour le `Name` champ du document avec une valeur littérale du type de données.
1. Interrogez le tableau pour obtenir la dernière révision du document.
1. Vérifiez que la valeur de `Name` a conservé ses propriétés de type de données d'origine en vérifiant qu'elle correspond au type attendu.
1. Déposez la `IonTypes` table.
**Note**
Avant d'exécuter ce code didacticiel, vous devez créer un registre nommé`vehicle-registration`.
------
#### [ Java ]
```
/*
* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: MIT-0
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this
* software and associated documentation files (the "Software"), to deal in the Software
* without restriction, including without limitation the rights to use, copy, modify,
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
package software.amazon.qldb.tutorial;
import com.amazon.ion.IonBlob;
import com.amazon.ion.IonBool;
import com.amazon.ion.IonClob;
import com.amazon.ion.IonDecimal;
import com.amazon.ion.IonFloat;
import com.amazon.ion.IonInt;
import com.amazon.ion.IonList;
import com.amazon.ion.IonNull;
import com.amazon.ion.IonSexp;
import com.amazon.ion.IonString;
import com.amazon.ion.IonStruct;
import com.amazon.ion.IonSymbol;
import com.amazon.ion.IonTimestamp;
import com.amazon.ion.IonValue;
import com.amazon.ion.Timestamp;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.Collections;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.qldb.Result;
import software.amazon.qldb.TransactionExecutor;
/**
* Insert all the supported Ion types into a ledger and verify that they are stored and can be retrieved properly, retaining
* their original properties.
*
* This code expects that you have AWS credentials setup per:
* http://docs.aws.amazon.com/java-sdk/latest/developer-guide/setup-credentials.html
*/
public class InsertIonTypes {
public static final Logger log = LoggerFactory.getLogger(InsertIonTypes.class);
public static final String TABLE_NAME = "IonTypes";
private InsertIonTypes() {}
/**
* Update a document's Name value in the database. Then, query the value of the Name key and verify the expected Ion type was
* saved.
*
* @param txn
* The {@link TransactionExecutor} for statement execution.
* @param ionValue
* The {@link IonValue} to set the document's Name value to.
*
* @throws AssertionError when no value is returned for the Name key or if the value does not match the expected type.
*/
public static void updateRecordAndVerifyType(final TransactionExecutor txn, final IonValue ionValue) {
final String updateStatement = String.format("UPDATE %s SET Name = ?", TABLE_NAME);
final List parameters = Collections.singletonList(ionValue);
txn.execute(updateStatement, parameters);
log.info("Updated document.");
final String searchQuery = String.format("SELECT VALUE Name FROM %s", TABLE_NAME);
final Result result = txn.execute(searchQuery);
if (result.isEmpty()) {
throw new AssertionError("Did not find any values for the Name key.");
}
for (IonValue value : result) {
if (!ionValue.getClass().isInstance(value)) {
throw new AssertionError(String.format("The queried value, %s, is not an instance of %s.",
value.getClass().toString(), ionValue.getClass().toString()));
}
if (!value.getType().equals(ionValue.getType())) {
throw new AssertionError(String.format("The queried value type, %s, does not match %s.",
value.getType().toString(), ionValue.getType().toString()));
}
}
log.info("Successfully verified value is instance of {} with type {}.", ionValue.getClass().toString(),
ionValue.getType().toString());
}
/**
* Delete a table.
*
* @param txn
* The {@link TransactionExecutor} for lambda execute.
* @param tableName
* The name of the table to delete.
*/
public static void deleteTable(final TransactionExecutor txn, final String tableName) {
log.info("Deleting {} table...", tableName);
final String statement = String.format("DROP TABLE %s", tableName);
txn.execute(statement);
log.info("{} table successfully deleted.", tableName);
}
public static void main(final String... args) {
final IonBlob ionBlob = Constants.SYSTEM.newBlob("hello".getBytes());
final IonBool ionBool = Constants.SYSTEM.newBool(true);
final IonClob ionClob = Constants.SYSTEM.newClob("{{'This is a CLOB of text.'}}".getBytes());
final IonDecimal ionDecimal = Constants.SYSTEM.newDecimal(0.1);
final IonFloat ionFloat = Constants.SYSTEM.newFloat(0.2);
final IonInt ionInt = Constants.SYSTEM.newInt(1);
final IonList ionList = Constants.SYSTEM.newList(new int[]{1, 2});
final IonNull ionNull = Constants.SYSTEM.newNull();
final IonSexp ionSexp = Constants.SYSTEM.newSexp(new int[]{2, 3});
final IonString ionString = Constants.SYSTEM.newString("string");
final IonStruct ionStruct = Constants.SYSTEM.newEmptyStruct();
ionStruct.put("brand", Constants.SYSTEM.newString("ford"));
final IonSymbol ionSymbol = Constants.SYSTEM.newSymbol("abc");
final IonTimestamp ionTimestamp = Constants.SYSTEM.newTimestamp(Timestamp.now());
final IonBlob ionNullBlob = Constants.SYSTEM.newNullBlob();
final IonBool ionNullBool = Constants.SYSTEM.newNullBool();
final IonClob ionNullClob = Constants.SYSTEM.newNullClob();
final IonDecimal ionNullDecimal = Constants.SYSTEM.newNullDecimal();
final IonFloat ionNullFloat = Constants.SYSTEM.newNullFloat();
final IonInt ionNullInt = Constants.SYSTEM.newNullInt();
final IonList ionNullList = Constants.SYSTEM.newNullList();
final IonSexp ionNullSexp = Constants.SYSTEM.newNullSexp();
final IonString ionNullString = Constants.SYSTEM.newNullString();
final IonStruct ionNullStruct = Constants.SYSTEM.newNullStruct();
final IonSymbol ionNullSymbol = Constants.SYSTEM.newNullSymbol();
final IonTimestamp ionNullTimestamp = Constants.SYSTEM.newNullTimestamp();
ConnectToLedger.getDriver().execute(txn -> {
CreateTable.createTable(txn, TABLE_NAME);
final Document document = new Document(Constants.SYSTEM.newString("val"));
InsertDocument.insertDocuments(txn, TABLE_NAME, Collections.singletonList(document));
updateRecordAndVerifyType(txn, ionBlob);
updateRecordAndVerifyType(txn, ionBool);
updateRecordAndVerifyType(txn, ionClob);
updateRecordAndVerifyType(txn, ionDecimal);
updateRecordAndVerifyType(txn, ionFloat);
updateRecordAndVerifyType(txn, ionInt);
updateRecordAndVerifyType(txn, ionList);
updateRecordAndVerifyType(txn, ionNull);
updateRecordAndVerifyType(txn, ionSexp);
updateRecordAndVerifyType(txn, ionString);
updateRecordAndVerifyType(txn, ionStruct);
updateRecordAndVerifyType(txn, ionSymbol);
updateRecordAndVerifyType(txn, ionTimestamp);
updateRecordAndVerifyType(txn, ionNullBlob);
updateRecordAndVerifyType(txn, ionNullBool);
updateRecordAndVerifyType(txn, ionNullClob);
updateRecordAndVerifyType(txn, ionNullDecimal);
updateRecordAndVerifyType(txn, ionNullFloat);
updateRecordAndVerifyType(txn, ionNullInt);
updateRecordAndVerifyType(txn, ionNullList);
updateRecordAndVerifyType(txn, ionNullSexp);
updateRecordAndVerifyType(txn, ionNullString);
updateRecordAndVerifyType(txn, ionNullStruct);
updateRecordAndVerifyType(txn, ionNullSymbol);
updateRecordAndVerifyType(txn, ionNullTimestamp);
deleteTable(txn, TABLE_NAME);
});
}
/**
* This class represents a simple document with a single key, Name, to use for the IonTypes table.
*/
private static class Document {
private final IonValue name;
@JsonCreator
private Document(@JsonProperty("Name") final IonValue name) {
this.name = name;
}
@JsonProperty("Name")
private IonValue getName() {
return name;
}
}
}
```
------
#### [ Node.js ]
```
/*
* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: MIT-0
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this
* software and associated documentation files (the "Software"), to deal in the Software
* without restriction, including without limitation the rights to use, copy, modify,
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
import { QldbDriver, Result, TransactionExecutor } from "amazon-qldb-driver-nodejs";
import { AssertionError } from "assert";
import { dom, IonType, IonTypes } from "ion-js";
import { insertDocument } from "./InsertDocument";
import { getQldbDriver } from "./ConnectToLedger";
import { createTable } from "./CreateTable";
import { error, log } from "./qldb/LogUtil";
const TABLE_NAME: string = "IonTypes";
/**
* Delete a table.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param tableName Name of the table to delete.
* @returns Promise which fulfills with void.
*/
export async function deleteTable(txn: TransactionExecutor, tableName: string): Promise {
log(`Deleting ${tableName} table...`);
const statement: string = `DROP TABLE ${tableName}`;
await txn.execute(statement);
log(`${tableName} table successfully deleted.`);
}
/**
* Update a document's Name value in QLDB. Then, query the value of the Name key and verify the expected Ion type was
* saved.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param parameter The IonValue to set the document's Name value to.
* @param ionType The Ion type that the Name value should be.
* @returns Promise which fulfills with void.
*/
async function updateRecordAndVerifyType(
txn: TransactionExecutor,
parameter: any,
ionType: IonType
): Promise {
const updateStatement: string = `UPDATE ${TABLE_NAME} SET Name = ?`;
await txn.execute(updateStatement, parameter);
log("Updated record.");
const searchStatement: string = `SELECT VALUE Name FROM ${TABLE_NAME}`;
const result: Result = await txn.execute(searchStatement);
const results: dom.Value[] = result.getResultList();
if (0 === results.length) {
throw new AssertionError({
message: "Did not find any values for the Name key."
});
}
results.forEach((value: dom.Value) => {
if (value.getType().binaryTypeId !== ionType.binaryTypeId) {
throw new AssertionError({
message: `The queried value type, ${value.getType().name}, does not match expected type, ${ionType.name}.`
});
}
});
log(`Successfully verified value is of type ${ionType.name}.`);
}
/**
* Insert all the supported Ion types into a table and verify that they are stored and can be retrieved properly,
* retaining their original properties.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbDriver: QldbDriver = getQldbDriver();
await qldbDriver.executeLambda(async (txn: TransactionExecutor) => {
await createTable(txn, TABLE_NAME);
await insertDocument(txn, TABLE_NAME, [{ "Name": "val" }]);
await updateRecordAndVerifyType(txn, dom.load("null"), IonTypes.NULL);
await updateRecordAndVerifyType(txn, true, IonTypes.BOOL);
await updateRecordAndVerifyType(txn, 1, IonTypes.INT);
await updateRecordAndVerifyType(txn, 3.2, IonTypes.FLOAT);
await updateRecordAndVerifyType(txn, dom.load("5.5"), IonTypes.DECIMAL);
await updateRecordAndVerifyType(txn, dom.load("2020-02-02"), IonTypes.TIMESTAMP);
await updateRecordAndVerifyType(txn, dom.load("abc123"), IonTypes.SYMBOL);
await updateRecordAndVerifyType(txn, dom.load("\"string\""), IonTypes.STRING);
await updateRecordAndVerifyType(txn, dom.load("{{ \"clob\" }}"), IonTypes.CLOB);
await updateRecordAndVerifyType(txn, dom.load("{{ blob }}"), IonTypes.BLOB);
await updateRecordAndVerifyType(txn, dom.load("(1 2 3)"), IonTypes.SEXP);
await updateRecordAndVerifyType(txn, dom.load("[1, 2, 3]"), IonTypes.LIST);
await updateRecordAndVerifyType(txn, dom.load("{brand: ford}"), IonTypes.STRUCT);
await deleteTable(txn, TABLE_NAME);
});
} catch (e) {
error(`Error updating and validating Ion types: ${e}`);
}
}
if (require.main === module) {
main();
}
```
------
#### [ Python ]
```
# Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
# software and associated documentation files (the "Software"), to deal in the Software
# without restriction, including without limitation the rights to use, copy, modify,
# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# This code expects that you have AWS credentials setup per:
# https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html
from datetime import datetime
from decimal import Decimal
from logging import basicConfig, getLogger, INFO
from amazon.ion.simple_types import IonPyBool, IonPyBytes, IonPyDecimal, IonPyDict, IonPyFloat, IonPyInt, IonPyList, \
IonPyNull, IonPySymbol, IonPyText, IonPyTimestamp
from amazon.ion.simpleion import loads
from amazon.ion.symbols import SymbolToken
from amazon.ion.core import IonType
from pyqldbsamples.create_table import create_table
from pyqldbsamples.constants import Constants
from pyqldbsamples.insert_document import insert_documents
from pyqldbsamples.model.sample_data import convert_object_to_ion
from pyqldbsamples.connect_to_ledger import create_qldb_driver
logger = getLogger(__name__)
basicConfig(level=INFO)
TABLE_NAME = 'IonTypes'
def update_record_and_verify_type(driver, parameter, ion_object, ion_type):
"""
Update a record in the database table. Then query the value of the record and verify correct ion type saved.
:type driver: :py:class:`pyqldb.driver.qldb_driver.QldbDriver`
:param driver: An instance of the QldbDriver class.
:type parameter: :py:class:`amazon.ion.simple_types.IonPyValue`
:param parameter: The Ion value or Python native type that is convertible to Ion for filling in parameters of the
statement.
:type ion_object: :py:obj:`IonPyBool`/:py:obj:`IonPyBytes`/:py:obj:`IonPyDecimal`/:py:obj:`IonPyDict`
/:py:obj:`IonPyFloat`/:py:obj:`IonPyInt`/:py:obj:`IonPyList`/:py:obj:`IonPyNull`
/:py:obj:`IonPySymbol`/:py:obj:`IonPyText`/:py:obj:`IonPyTimestamp`
:param ion_object: The Ion object to verify against.
:type ion_type: :py:class:`amazon.ion.core.IonType`
:param ion_type: The Ion type to verify against.
:raises TypeError: When queried value is not an instance of Ion type.
"""
update_query = 'UPDATE {} SET Name = ?'.format(TABLE_NAME)
driver.execute_lambda(lambda executor: executor.execute_statement(update_query, parameter))
logger.info('Updated record.')
search_query = 'SELECT VALUE Name FROM {}'.format(TABLE_NAME)
cursor = driver.execute_lambda(lambda executor: executor.execute_statement(search_query))
for c in cursor:
if not isinstance(c, ion_object):
raise TypeError('The queried value is not an instance of {}'.format(ion_object.__name__))
if c.ion_type is not ion_type:
raise TypeError('The queried value type does not match {}'.format(ion_type))
logger.info("Successfully verified value is instance of '{}' with type '{}'.".format(ion_object.__name__, ion_type))
return cursor
def delete_table(driver, table_name):
"""
Delete a table.
:type driver: :py:class:`pyqldb.driver.qldb_driver.QldbDriver`
:param driver: An instance of the QldbDriver class.
:type table_name: str
:param table_name: Name of the table to delete.
:rtype: int
:return: The number of changes to the database.
"""
logger.info("Deleting '{}' table...".format(table_name))
cursor = driver.execute_lambda(lambda executor: executor.execute_statement('DROP TABLE {}'.format(table_name)))
logger.info("'{}' table successfully deleted.".format(table_name))
return len(list(cursor))
def insert_and_verify_ion_types(driver):
"""
Insert all the supported Ion types and Python values that are convertible to Ion into a ledger and verify that they
are stored and can be retrieved properly, retaining their original properties.
:type driver: :py:class:`pyqldb.driver.qldb_driver.QldbDriver`
:param driver: A QLDB Driver object.
"""
python_bytes = str.encode('hello')
python_bool = True
python_float = float('0.2')
python_decimal = Decimal('0.1')
python_string = "string"
python_int = 1
python_null = None
python_datetime = datetime(2016, 12, 20, 5, 23, 43)
python_list = [1, 2]
python_dict = {"brand": "Ford"}
ion_clob = convert_object_to_ion(loads('{{"This is a CLOB of text."}}'))
ion_blob = convert_object_to_ion(python_bytes)
ion_bool = convert_object_to_ion(python_bool)
ion_decimal = convert_object_to_ion(python_decimal)
ion_float = convert_object_to_ion(python_float)
ion_int = convert_object_to_ion(python_int)
ion_list = convert_object_to_ion(python_list)
ion_null = convert_object_to_ion(python_null)
ion_sexp = convert_object_to_ion(loads('(cons 1 2)'))
ion_string = convert_object_to_ion(python_string)
ion_struct = convert_object_to_ion(python_dict)
ion_symbol = convert_object_to_ion(SymbolToken(text='abc', sid=123))
ion_timestamp = convert_object_to_ion(python_datetime)
ion_null_clob = convert_object_to_ion(loads('null.clob'))
ion_null_blob = convert_object_to_ion(loads('null.blob'))
ion_null_bool = convert_object_to_ion(loads('null.bool'))
ion_null_decimal = convert_object_to_ion(loads('null.decimal'))
ion_null_float = convert_object_to_ion(loads('null.float'))
ion_null_int = convert_object_to_ion(loads('null.int'))
ion_null_list = convert_object_to_ion(loads('null.list'))
ion_null_sexp = convert_object_to_ion(loads('null.sexp'))
ion_null_string = convert_object_to_ion(loads('null.string'))
ion_null_struct = convert_object_to_ion(loads('null.struct'))
ion_null_symbol = convert_object_to_ion(loads('null.symbol'))
ion_null_timestamp = convert_object_to_ion(loads('null.timestamp'))
create_table(driver, TABLE_NAME)
insert_documents(driver, TABLE_NAME, [{'Name': 'val'}])
update_record_and_verify_type(driver, python_bytes, IonPyBytes, IonType.BLOB)
update_record_and_verify_type(driver, python_bool, IonPyBool, IonType.BOOL)
update_record_and_verify_type(driver, python_float, IonPyFloat, IonType.FLOAT)
update_record_and_verify_type(driver, python_decimal, IonPyDecimal, IonType.DECIMAL)
update_record_and_verify_type(driver, python_string, IonPyText, IonType.STRING)
update_record_and_verify_type(driver, python_int, IonPyInt, IonType.INT)
update_record_and_verify_type(driver, python_null, IonPyNull, IonType.NULL)
update_record_and_verify_type(driver, python_datetime, IonPyTimestamp, IonType.TIMESTAMP)
update_record_and_verify_type(driver, python_list, IonPyList, IonType.LIST)
update_record_and_verify_type(driver, python_dict, IonPyDict, IonType.STRUCT)
update_record_and_verify_type(driver, ion_clob, IonPyBytes, IonType.CLOB)
update_record_and_verify_type(driver, ion_blob, IonPyBytes, IonType.BLOB)
update_record_and_verify_type(driver, ion_bool, IonPyBool, IonType.BOOL)
update_record_and_verify_type(driver, ion_decimal, IonPyDecimal, IonType.DECIMAL)
update_record_and_verify_type(driver, ion_float, IonPyFloat, IonType.FLOAT)
update_record_and_verify_type(driver, ion_int, IonPyInt, IonType.INT)
update_record_and_verify_type(driver, ion_list, IonPyList, IonType.LIST)
update_record_and_verify_type(driver, ion_null, IonPyNull, IonType.NULL)
update_record_and_verify_type(driver, ion_sexp, IonPyList, IonType.SEXP)
update_record_and_verify_type(driver, ion_string, IonPyText, IonType.STRING)
update_record_and_verify_type(driver, ion_struct, IonPyDict, IonType.STRUCT)
update_record_and_verify_type(driver, ion_symbol, IonPySymbol, IonType.SYMBOL)
update_record_and_verify_type(driver, ion_timestamp, IonPyTimestamp, IonType.TIMESTAMP)
update_record_and_verify_type(driver, ion_null_clob, IonPyNull, IonType.CLOB)
update_record_and_verify_type(driver, ion_null_blob, IonPyNull, IonType.BLOB)
update_record_and_verify_type(driver, ion_null_bool, IonPyNull, IonType.BOOL)
update_record_and_verify_type(driver, ion_null_decimal, IonPyNull, IonType.DECIMAL)
update_record_and_verify_type(driver, ion_null_float, IonPyNull, IonType.FLOAT)
update_record_and_verify_type(driver, ion_null_int, IonPyNull, IonType.INT)
update_record_and_verify_type(driver, ion_null_list, IonPyNull, IonType.LIST)
update_record_and_verify_type(driver, ion_null_sexp, IonPyNull, IonType.SEXP)
update_record_and_verify_type(driver, ion_null_string, IonPyNull, IonType.STRING)
update_record_and_verify_type(driver, ion_null_struct, IonPyNull, IonType.STRUCT)
update_record_and_verify_type(driver, ion_null_symbol, IonPyNull, IonType.SYMBOL)
update_record_and_verify_type(driver, ion_null_timestamp, IonPyNull, IonType.TIMESTAMP)
delete_table(driver, TABLE_NAME)
def main(ledger_name=Constants.LEDGER_NAME):
"""
Insert all the supported Ion types and Python values that are convertible to Ion into a ledger and verify that they
are stored and can be retrieved properly, retaining their original properties.
"""
try:
with create_qldb_driver(ledger_name) as driver:
insert_and_verify_ion_types(driver)
except Exception as e:
logger.exception('Error updating and validating Ion types.')
raise e
if __name__ == '__main__':
main()
```
------