Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Referenz zum Amazon Ion-Datenformat in Amazon QLDB
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
[Amazon QLDB verwendet ein Datennotationsmodell, das [Amazon Ion](http://amzn.github.io/ion-docs/) mit einer Teilmenge von PartiQL-Typen vereint.](https://partiql.org/) Dieser Abschnitt bietet eine Referenzübersicht über das Ion-Dokument-Datenformat, unabhängig von dessen Integration in PartiQL.
**Abfragen von Ion mit PartiQL in Amazon QLDB**
*Informationen zur Syntax und Semantik der Abfrage von Ion-Daten mit PartiQL in QLDB finden Sie [Abfragen von Ion mit PartiQL](ql-reference.query.md) in der Amazon QLDB PartiQL-Referenz.*
Codebeispiele, die Ion-Daten in einem QLDB-Ledger abfragen und verarbeiten, finden Sie unter und. [Beispiele für Amazon Ion-Code](ion.code-examples.md) [Arbeiten mit Amazon Ion](driver-working-with-ion.md)
**Topics**
+ [
## Was ist Amazon Ion?
](#ion.summary)
+ [
## Ionenspezifikation
](#ion.spec)
+ [
## JSON-kompatibel
](#ion.json-compatible)
+ [
## Erweiterungen von JSON
](#ion.json-ext)
+ [
## Beispiel für Ionentext
](#ion.example)
+ [
## API-Referenzen
](#ion.api-ref)
+ [
# Amazon Ion-Codebeispiele in QLDB
](ion.code-examples.md)
## Was ist Amazon Ion?
Hierbei handelt es sich um ein Open-Source-, stark typisiertes, selbstbeschreibendes, hierarchisches Daten-Serialisierungsformat, das ursprünglich intern bei Amazon entwickelt wurde. Es basiert auf einem abstrakten Datenmodell, mit dem Sie sowohl strukturierte als auch unstrukturierte Daten speichern können. Es ist eine Obermenge von JSON, was bedeutet, dass jedes gültige JSON-Dokument auch ein gültiges Ion-Dokument ist. In diesem Handbuch wird davon ausgegangen, dass ein grundlegendes praktisches Wissen zu JSON vorhanden ist. Wenn Sie mit JSON noch nicht vertraut sind, finden Sie weitere Informationen unter [Einführung in JSON](http://json.org).
Sie können Ion-Dokumente austauschbar entweder in Form von lesbarem Text oder in binär-kodierter Form verwenden. Wie JSON lässt sich die Textform leicht lesen und schreiben und unterstützt schnelles Prototyping. Die binäre Codierung ist kompakter und lässt sich effizient beibehalten, übertragen und analysieren. Ein Ion-Prozessor kann zwischen beiden Formaten transcodieren, um genau denselben Satz an Datenstrukturen ohne Datenverlust darzustellen. Mit dieser Funktion können Anwendungen die Datenverarbeitung für verschiedene Anwendungsfälle optimieren.
**Anmerkung**
Das Ion-Datenmodell basiert ausschließlich auf Werten und unterstützt keine Referenzen. Auf diese Weise kann das Datenmodell Hierarchien darstellen, die in beliebiger Tiefe verschachtelt werden können, jedoch keine gezielten Diagramme.
## Ionenspezifikation
Eine vollständige Liste der Ion-Core-Datentypen mit vollständigen Beschreibungen und Angaben zur Wertformatierung finden Sie im [Ion-Spezifikationsdokument](http://amzn.github.io/ion-docs/docs/spec.html) auf der GitHub Amazon-Website.
Um die Anwendungsentwicklung zu optimieren, bietet Amazon Ion Client-Bibliotheken, die Ion-Daten für Sie verarbeiten. Codebeispiele für gängige Anwendungsfälle für die Verarbeitung von Ion-Daten finden Sie im [Amazon Ion Cookbook](http://amzn.github.io/ion-docs/guides/cookbook.html) unter. GitHub
## JSON-kompatibel
Ähnlich wie bei JSON verfassen Sie Amazon Ion-Dokumente mit einer Reihe von primitiven Datentypen und einer Reihe von rekursiv definierten Containertypen. Ion enthält die folgenden traditionellen JSON-Datentypen:
+ `null`: Ein generischer, nicht typisierter Null-Wert (leer). Außerdem unterstützt Ion einen eindeutigen Null-Typ für jeden primitiven Typ, wie im folgenden Abschnitt beschrieben.
+ `bool`: Boolesche Werte.
+ `string`: Unicode-Textliterale.
+ `list`: Zulässige heterogene Sammlungen von Werten.
+ `struct`: Nicht zulässige Sammlungen von Schlüssel-Wert-Paaren. Wie JSON erlaubt auch `struct` mehrere Werte pro Schlüssel, aber davon wird in der Regel abgeraten.
## Erweiterungen von JSON
### Typen von Zahlen
Anstelle des mehrdeutigen JSON-`number`-Typs, definiert Amazon Ion Zahlen streng als einen der folgenden Typen:
+ `int`: Signierte Ganzzahlen von beliebiger Größe.
+ `decimal`: Dezimal-kodierte echte Zahlen von beliebiger Präzision.
+ `float`: Binär-kodierte Gleitkommazahlen (64-Bit-IEEE).
Beim Analysieren von Dokumenten weist ein Ion-Prozessor Zahlentypen wie folgt zu:
+ `int`: Zahlen ohne Exponent oder Dezimaltrennzeichen (z. B. `100200`).
+ `decimal`: Zahlen mit einem Dezimaltrennzeichen und keinem Exponent (z. B. `0.00001`, `200.0`).
+ `float`: Zahlen mit einem Exponenten, wie z. B. einer wissenschaftlichen Notation oder E-Notation (z. B. `2e0`, `3.1e-4`).
### Neue Datentypen
Amazon Ion fügt die folgenden Datentypen hinzu:
+ `timestamp`: Date/time/timezone Momente beliebiger Genauigkeit.
+ `symbol`: Symbolische Unicode-Atome (z. B. Kennungen).
+ `blob`: Binäre Daten der benutzerdefinierten Kodierung.
+ `clob`: Textdaten der benutzerdefinierten Kodierung.
+ `sexp`: Zulässige Sammlungen von Werten mit anwendungsdefinierter Semantik.
### Null-Typen
Zusätzlich zu den allgemeinen Null-Typ, die von JSON definiert sind, unterstützt Amazon Ion einen eindeutigen Null-Typ für jeden primitiven Typ. Dies gibt einen fehlenden Wert an, während ein strenger Datentyp beibehalten wird.
```
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
```
## Beispiel für Ionentext
```
// 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
],
}
```
## API-Referenzen
+ [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/)
# Amazon Ion-Codebeispiele in QLDB
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
Dieser Abschnitt enthält Codebeispiele, die Amazon Ion-Daten verarbeiten, indem sie Dokumentwerte in ein Amazon QLDB-Ledger lesen und schreiben. Die Codebeispiele verwenden den QLDB-Treiber, um PartiQL-Anweisungen auf dem Ledger auszuführen. [Diese Beispiele sind Teil der Beispielanwendung in [Erste Schritte mit Amazon QLDB mithilfe eines Tutorials für eine Beispielanwendung](getting-started-sample-app.md) und stehen als Open Source auf der Beispielseite zur Verfügung.AWS GitHub ](https://github.com/aws-samples/?q=qldb)
Allgemeine Codebeispiele, die allgemeine Anwendungsfälle der Verarbeitung von Ion-Daten zeigen, finden Sie im [Amazon Ion Cookbook](http://amzn.github.io/ion-docs/guides/cookbook.html) unter. GitHub
## Ausführen des Codes
Der Tutorial-Code für jede Programmiersprache führt die folgenden Schritte aus:
1. Stellen Sie eine Verbindung mit dem `vehicle-registration`-Beispiel-Ledger her.
1. Erstellen Sie eine Tabelle mit dem Namen „`IonTypes`“.
1. Fügen Sie ein Dokument mit einem einzigen `Name`-Feld in die Tabelle ein.
1. Für jeden unterstützten [Ion-Datentyp](http://amzn.github.io/ion-docs/docs/spec.html):
1. Aktualisieren Sie das `Name`-Dokumentfeld mit einem Literalwert des Datentyps.
1. Fragen Sie die Tabelle ab, um die neueste Version des Dokuments zu erhalten.
1. Überprüfen Sie, ob der Wert „`Name`“ seine ursprünglichen Datentypeigenschaften beibehalten hat, indem Sie überprüfen, ob er mit dem erwarteten Typ übereinstimmt.
1. Löschen Sie die `IonTypes` Tabelle.
**Anmerkung**
Bevor Sie diesen Tutorial-Code ausführen, müssen Sie ein Ledger mit dem Namen „`vehicle-registration`“ erstellen.
------
#### [ 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()
```
------