Trabajo con tipos de datos de Amazon Ion en Amazon QLDB - Amazon Quantum Ledger Database (Amazon QLDB)

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Trabajo con tipos de datos de Amazon Ion en Amazon QLDB

Amazon QLDB almacena sus datos en formato Amazon Ion. Para trabajar con datos en QLDB, debe utilizar unBiblioteca Ioncomo dependencia de un lenguaje de programación compatible.

En esta sección, aprenda a convertir datos de tipos nativos a sus equivalentes de iones y al revés. Esta guía de referencia muestra ejemplos de código que utilizan el controlador QLDB para procesar datos de iones en un libro mayor QLDB. Incluye ejemplos de código para Java, .NET (C#), Go, Node.js (TypeScript) y Python.

Requisitos previos

En los siguientes ejemplos de código se supone que tiene una instancia de controlador QLDB conectada a un libro mayor activo con una tabla denominadaExampleTable. La tabla contiene un único documento existente que tiene los ocho campos siguientes:

  • ExampleBool

  • ExampleInt

  • ExampleFloat

  • ExampleDecimal

  • ExampleTimestamp

  • ExampleString

  • ExampleBlob

  • ExampleList

nota

A efectos de esta referencia, supongamos que el tipo almacenado en cada campo coincide con su nombre. En la práctica, QLDB no aplica definiciones de esquemas o tipos de datos para los campos de documento.

Bool

En los siguientes ejemplos de código, se muestra cómo procesar el tipo booleano Ion.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); boolean exampleBoolean = driver.execute((txn) -> { // Transforming a Java boolean to Ion boolean aBoolean = true; IonValue ionBool = ionSystem.newBool(aBoolean); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleBool = ?", ionBool); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleBool from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java boolean // Cast IonValue to IonBool first aBoolean = ((IonBool)ionValue).booleanValue(); } // exampleBoolean is now the value fetched from QLDB return aBoolean; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# bool to Ion. bool nativeBool = true; IIonValue ionBool = valueFactory.NewBool(nativeBool); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleBool = ?", ionBool); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleBool from ExampleTable"); }); bool? retrievedBool = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# bool. retrievedBool = ionValue.BoolValue; }
nota

Para convertir en código síncrono, elimine elawaityasyncpalabras clave y cambie laIAsyncResultescriba aIResult.

Go
exampleBool, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aBool := true // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleBool = ?", aBool) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleBool FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult bool err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleBool is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonBoolean(driver: QldbDriver): Promise<boolean> { return (driver.executeLambda(async (txn: TransactionExecutor) => { // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleBool = ?", true); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleBool FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to a TypeScript Boolean const boolValue: boolean = ionValue.booleanValue(); return boolValue; }) ); }
Python
def update_and_query_ion_bool(txn): # QLDB can take in a Python bool a_bool = True # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleBool = ?", a_bool) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleBool FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python bool is a child class of Python bool a_bool = ion_value # example_bool is now the value fetched from QLDB return a_bool example_bool = driver.execute_lambda(lambda txn: update_and_query_ion_bool(txn))

Int

En los siguientes ejemplos de código, se muestra cómo procesar el tipo de entero Ion.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); int exampleInt = driver.execute((txn) -> { // Transforming a Java int to Ion int aInt = 256; IonValue ionInt = ionSystem.newInt(aInt); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleInt = ?", ionInt); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleInt from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java int // Cast IonValue to IonInt first aInt = ((IonInt)ionValue).intValue(); } // exampleInt is now the value fetched from QLDB return aInt; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# int to Ion. int nativeInt = 256; IIonValue ionInt = valueFactory.NewInt(nativeInt); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleInt = ?", ionInt); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleInt from ExampleTable"); }); int? retrievedInt = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# int. retrievedInt = ionValue.IntValue; }
nota

Para convertir en código síncrono, elimine elawaityasyncpalabras clave y cambie laIAsyncResultescriba aIResult.

Go
exampleInt, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aInt := 256 // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleInt = ?", aInt) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleInt FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult int err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleInt is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonInt(driver: QldbDriver): Promise<number> { return (driver.executeLambda(async (txn: TransactionExecutor) => { // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleInt = ?", 256); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleInt FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to a TypeScript Number const intValue: number = ionValue.numberValue(); return intValue; }) ); }
Python
def update_and_query_ion_int(txn): # QLDB can take in a Python int a_int = 256 # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleInt = ?", a_int) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleInt FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python int is a child class of Python int a_int = ion_value # example_int is now the value fetched from QLDB return a_int example_int = driver.execute_lambda(lambda txn: update_and_query_ion_int(txn))

Float

En los siguientes ejemplos de código, se muestra cómo procesar el tipo de flotante Ion.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); float exampleFloat = driver.execute((txn) -> { // Transforming a Java float to Ion float aFloat = 256; IonValue ionFloat = ionSystem.newFloat(aFloat); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleFloat = ?", ionFloat); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleFloat from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java float // Cast IonValue to IonFloat first aFloat = ((IonFloat)ionValue).floatValue(); } // exampleFloat is now the value fetched from QLDB return aFloat; });
.NET

Uso de C# float

using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# float to Ion. float nativeFloat = 256; IIonValue ionFloat = valueFactory.NewFloat(nativeFloat); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleFloat = ?", ionFloat); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleFloat from ExampleTable"); }); float? retrievedFloat = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# float. We cast ionValue.DoubleValue to a float // but be cautious, this is a down-cast and can lose precision. retrievedFloat = (float)ionValue.DoubleValue; }
nota

Para convertir en código síncrono, elimine elawaityasyncpalabras clave y cambie laIAsyncResultescriba aIResult.

Uso de C# double

using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# double to Ion. double nativeDouble = 256; IIonValue ionFloat = valueFactory.NewFloat(nativeDouble); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleFloat = ?", ionFloat); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleFloat from ExampleTable"); }); double? retrievedDouble = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# double. retrievedDouble = ionValue.DoubleValue; }
nota

Para convertir en código síncrono, elimine elawaityasyncpalabras clave y cambie laIAsyncResultescriba aIResult.

Go
exampleFloat, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aFloat := float32(256) // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleFloat = ?", aFloat) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleFloat FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { // float64 would work as well var decodedResult float32 err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleFloat is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonFloat(driver: QldbDriver): Promise<number> { return (driver.executeLambda(async (txn: TransactionExecutor) => { // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleFloat = ?", 25.6); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleFloat FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to a TypeScript Number const floatValue: number = ionValue.numberValue(); return floatValue; }) ); }
Python
def update_and_query_ion_float(txn): # QLDB can take in a Python float a_float = float(256) # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleFloat = ?", a_float) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleFloat FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python float is a child class of Python float a_float = ion_value # example_float is now the value fetched from QLDB return a_float example_float = driver.execute_lambda(lambda txn: update_and_query_ion_float(txn))

Decimal

En los siguientes ejemplos de código, se muestra cómo procesar el tipo decimal Ion.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); double exampleDouble = driver.execute((txn) -> { // Transforming a Java double to Ion double aDouble = 256; IonValue ionDecimal = ionSystem.newDecimal(aDouble); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleDecimal = ?", ionDecimal); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleDecimal from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java double // Cast IonValue to IonDecimal first aDouble = ((IonDecimal)ionValue).doubleValue(); } // exampleDouble is now the value fetched from QLDB return aDouble; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# decimal to Ion. decimal nativeDecimal = 256.8723m; IIonValue ionDecimal = valueFactory.NewDecimal(nativeDecimal); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleDecimal = ?", ionDecimal); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleDecimal from ExampleTable"); }); decimal? retrievedDecimal = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# decimal. retrievedDecimal = ionValue.DecimalValue; }
nota

Para convertir en código síncrono, elimine elawaityasyncpalabras clave y cambie laIAsyncResultescriba aIResult.

Go
exampleDecimal, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aDecimal, err := ion.ParseDecimal("256") if err != nil { return nil, err } // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleDecimal = ?", aDecimal) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleDecimal FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult ion.Decimal err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleDecimal is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonDecimal(driver: QldbDriver): Promise<Decimal> { return (driver.executeLambda(async (txn: TransactionExecutor) => { // Creating a Decimal value. Decimal is an Ion Type with high precision let ionDecimal: Decimal = dom.load("2.5d-6").decimalValue(); // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleDecimal = ?", ionDecimal); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleDecimal FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Get the Ion Decimal ionDecimal = ionValue.decimalValue(); return ionDecimal; }) ); }
nota

También puede utilizarionValue.numberValue()para transformar un decimal de iones en unJavaScriptnúmero. Uso deionValue.numberValue()tiene un mejor rendimiento, pero es menos preciso.

Python
def update_and_query_ion_decimal(txn): # QLDB can take in a Python decimal a_decimal = Decimal(256) # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleDecimal = ?", a_decimal) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleDecimal FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python decimal is a child class of Python decimal a_decimal = ion_value # example_decimal is now the value fetched from QLDB return a_decimal example_decimal = driver.execute_lambda(lambda txn: update_and_query_ion_decimal(txn))

Marca temporal

En los siguientes ejemplos de código, se muestra cómo procesar el tipo de marca de hora Ion.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); Date exampleDate = driver.execute((txn) -> { // Transforming a Java Date to Ion Date aDate = new Date(); IonValue ionTimestamp = ionSystem.newUtcTimestamp(aDate); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleTimestamp = ?", ionTimestamp); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleTimestamp from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java Date // Cast IonValue to IonTimestamp first aDate = ((IonTimestamp)ionValue).dateValue(); } // exampleDate is now the value fetched from QLDB return aDate; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; using Amazon.IonDotnet; ... IValueFactory valueFactory = new ValueFactory(); // Convert C# native DateTime to Ion. DateTime nativeDateTime = DateTime.Now; // First convert it to a timestamp object from Ion. Timestamp timestamp = new Timestamp(nativeDateTime); // Then convert to Ion timestamp. IIonValue ionTimestamp = valueFactory.NewTimestamp(timestamp); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleTimestamp = ?", ionTimestamp); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleTimestamp from ExampleTable"); }); DateTime? retrievedDateTime = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# DateTime. retrievedDateTime = ionValue.TimestampValue.DateTimeValue; }
nota

Para convertir en código síncrono, elimine elawaityasyncpalabras clave y cambie laIAsyncResultescriba aIResult.

Go
exampleTimestamp, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aTimestamp := time.Date(2006, time.May, 20, 12, 30, 0, 0, time.UTC) if err != nil { return nil, err } // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleTimestamp = ?", aTimestamp) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleTimestamp FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult ion.Timestamp err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleTimestamp is now the value fetched from QLDB return decodedResult.GetDateTime(), nil } return nil, result.Err() })
Node.js
async function queryIonTimestamp(driver: QldbDriver): Promise<Date> { return (driver.executeLambda(async (txn: TransactionExecutor) => { let exampleDateTime: Date = new Date(Date.now()); // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleTimestamp = ?", exampleDateTime); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleTimestamp FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to a TypeScript Date exampleDateTime = ionValue.timestampValue().getDate(); return exampleDateTime; }) ); }
Python
def update_and_query_ion_timestamp(txn): # QLDB can take in a Python timestamp a_datetime = datetime.now() # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleTimestamp = ?", a_datetime) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleTimestamp FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python timestamp is a child class of Python datetime a_timestamp = ion_value # example_timestamp is now the value fetched from QLDB return a_timestamp example_timestamp = driver.execute_lambda(lambda txn: update_and_query_ion_timestamp(txn))

Cadena

En los siguientes ejemplos de código, se muestra cómo procesar el tipo de cadena Ion.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); String exampleString = driver.execute((txn) -> { // Transforming a Java String to Ion String aString = "Hello world!"; IonValue ionString = ionSystem.newString(aString); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleString = ?", ionString); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleString from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java String // Cast IonValue to IonString first aString = ((IonString)ionValue).stringValue(); } // exampleString is now the value fetched from QLDB return aString; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Convert C# string to Ion. String nativeString = "Hello world!"; IIonValue ionString = valueFactory.NewString(nativeString); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleString = ?", ionString); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleString from ExampleTable"); }); String retrievedString = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# string. retrievedString = ionValue.StringValue; }
nota

Para convertir en código síncrono, elimine elawaityasyncpalabras clave y cambie laIAsyncResultescriba aIResult.

Go
exampleString, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aString := "Hello World!" // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleString = ?", aString) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleString FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult string err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleString is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonString(driver: QldbDriver): Promise<string> { return (driver.executeLambda(async (txn: TransactionExecutor) => { // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleString = ?", "Hello World!"); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleString FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to a TypeScript String const stringValue: string = ionValue.stringValue(); return stringValue; }) ); }
Python
def update_and_query_ion_string(txn): # QLDB can take in a Python string a_string = "Hello world!" # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleString = ?", a_string) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleString FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python string is a child class of Python string a_string = ion_value # example_string is now the value fetched from QLDB return a_string example_string = driver.execute_lambda(lambda txn: update_and_query_ion_string(txn))

Blob

En los siguientes ejemplos de código, se muestra cómo procesar el tipo de blob Ion.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); byte[] exampleBytes = driver.execute((txn) -> { // Transforming a Java byte array to Ion // Transform any arbitrary data to a byte array to store in QLDB String aString = "Hello world!"; byte[] aByteArray = aString.getBytes(); IonValue ionBlob = ionSystem.newBlob(aByteArray); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleBlob = ?", ionBlob); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleBlob from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java byte array // Cast IonValue to IonBlob first aByteArray = ((IonBlob)ionValue).getBytes(); } // exampleBytes is now the value fetched from QLDB return aByteArray; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; using System.Text; ... IValueFactory valueFactory = new ValueFactory(); // Transform any arbitrary data to a byte array to store in QLDB. string nativeString = "Hello world!"; byte[] nativeByteArray = Encoding.UTF8.GetBytes(nativeString); // Transforming a C# byte array to Ion. IIonValue ionBlob = valueFactory.NewBlob(nativeByteArray); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleBlob = ?", ionBlob); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleBlob from ExampleTable"); }); byte[] retrievedByteArray = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# byte array. retrievedByteArray = ionValue.Bytes().ToArray(); }
nota

Para convertir en código síncrono, elimine elawaityasyncpalabras clave y cambie laIAsyncResultescriba aIResult.

Go
exampleBlob, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aBlob := []byte("Hello World!") // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleBlob = ?", aBlob) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleBlob FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult []byte err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleBlob is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonBlob(driver: QldbDriver): Promise<Uint8Array> { return (driver.executeLambda(async (txn: TransactionExecutor) => { const enc = new TextEncoder(); let blobValue: Uint8Array = enc.encode("Hello World!"); // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleBlob = ?", blobValue); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleBlob FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to TypeScript Uint8Array blobValue = ionValue.uInt8ArrayValue(); return blobValue; }) ); }
Python
def update_and_query_ion_blob(txn): # QLDB can take in a Python byte array a_string = "Hello world!" a_byte_array = str.encode(a_string) # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleBlob = ?", a_byte_array) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleBlob FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python blob is a child class of Python byte array a_blob = ion_value # example_blob is now the value fetched from QLDB return a_blob example_blob = driver.execute_lambda(lambda txn: update_and_query_ion_blob(txn))

List

En los siguientes ejemplos de código, se muestra cómo procesar el tipo de lista Ion.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); List<Integer> exampleList = driver.execute((txn) -> { // Transforming a Java List to Ion List<Integer> aList = new ArrayList<>(); // Add 5 Integers to the List for the sake of example for (int i = 0; i < 5; i++) { aList.add(i); } // Create an empty Ion List IonList ionList = ionSystem.newEmptyList(); // Add the 5 Integers to the Ion List for (Integer i : aList) { // Convert each Integer to Ion ints first to add it to the Ion List ionList.add(ionSystem.newInt(i)); } // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleList = ?", (IonValue) ionList); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleList from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Iterate through the Ion List to map it to a Java List List<Integer> intList = new ArrayList<>(); for (IonValue ionInt : (IonList)ionValue) { // Convert the 5 Ion ints to Java Integers intList.add(((IonInt)ionInt).intValue()); } aList = intList; } // exampleList is now the value fetched from QLDB return aList; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; using System.Collections.Generic; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# list to Ion. IIonValue ionList = valueFactory.NewEmptyList(); foreach (int i in new List<int> {0, 1, 2, 3, 4}) { // Convert to Ion int and add to Ion list. ionList.Add(valueFactory.NewInt(i)); } IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleList = ?", ionList); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleList from ExampleTable"); }); List<int> retrievedList = new List<int>(); await foreach (IIonValue ionValue in selectResult) { // Iterate through the Ion List to map it to a C# list. foreach (IIonValue ionInt in ionValue) { retrievedList.Add(ionInt.IntValue); } }
nota

Para convertir en código síncrono, elimine elawaityasyncpalabras clave y cambie laIAsyncResultescriba aIResult.

Go
exampleList, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aList := []int{1, 2, 3, 4, 5} // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleList = ?", aList) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleList FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult []int err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleList is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonList(driver: QldbDriver): Promise<number[]> { return (driver.executeLambda(async (txn: TransactionExecutor) => { let listOfNumbers: number[] = [1, 2, 3, 4, 5]; // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleList = ?", listOfNumbers); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleList FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Get Ion List const ionList: dom.Value[] = ionValue.elements(); // Iterate through the Ion List to map it to a JavaScript Array let intList: number[] = []; ionList.forEach(item => { // Transforming Ion to a TypeScript Number const intValue: number = item.numberValue(); intList.push(intValue); }); listOfNumbers = intList; return listOfNumbers; }) ); }
Python
def update_and_query_ion_list(txn): # QLDB can take in a Python list a_list = list() for i in range(0, 5): a_list.append(i) # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleList = ?", a_list) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleList FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python blob is a child class of Python list a_list = ion_value # example_list is now the value fetched from QLDB return a_list example_list = driver.execute_lambda(lambda txn: update_and_query_ion_list(txn))

struct

En QLDB,structlos tipos de datos son especialmente exclusivos de otros tipos de iones. Los documentos de nivel superior que inserte en una tabla deben ser delstruct. Un campo de documento también puede almacenar un anidadostruct.

Para simplificar, en los siguientes ejemplos se define un documento que contiene laExampleStringyExampleIntsolo campos.

Java
class ExampleStruct { public String exampleString; public int exampleInt; public ExampleStruct(String exampleString, int exampleInt) { this.exampleString = exampleString; this.exampleInt = exampleInt; } } // Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); ExampleStruct examplePojo = driver.execute((txn) -> { // Transforming a POJO to Ion ExampleStruct aPojo = new ExampleStruct("Hello world!", 256); // Create an empty Ion struct IonStruct ionStruct = ionSystem.newEmptyStruct(); // Map the fields of the POJO to Ion values and put them in the Ion struct ionStruct.add("ExampleString", ionSystem.newString(aPojo.exampleString)); ionStruct.add("ExampleInt", ionSystem.newInt(aPojo.exampleInt)); // Insertion into QLDB txn.execute("INSERT INTO ExampleTable ?", ionStruct); // Fetching from QLDB Result result = txn.execute("SELECT * from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Map the fields of the Ion struct to Java values and construct a new POJO ionStruct = (IonStruct)ionValue; IonString exampleString = (IonString)ionStruct.get("ExampleString"); IonInt exampleInt = (IonInt)ionStruct.get("ExampleInt"); aPojo = new ExampleStruct(exampleString.stringValue(), exampleInt.intValue()); } // examplePojo is now the document fetched from QLDB return aPojo; });

También puede utilizar laBiblioteca Jacksonpara asignar tipos de datos desde y hacia Ion. La biblioteca admite los demás tipos de datos de Ion, pero este ejemplo se centra en elstruct.

class ExampleStruct { public String exampleString; public int exampleInt; @JsonCreator public ExampleStruct(@JsonProperty("ExampleString") String exampleString, @JsonProperty("ExampleInt") int exampleInt) { this.exampleString = exampleString; this.exampleInt = exampleInt; } @JsonProperty("ExampleString") public String getExampleString() { return this.exampleString; } @JsonProperty("ExampleInt") public int getExampleInt() { return this.exampleInt; } } // Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); // Instantiate an IonObjectMapper from the Jackson library IonObjectMapper ionMapper = new IonValueMapper(ionSystem); ExampleStruct examplePojo = driver.execute((txn) -> { // Transforming a POJO to Ion ExampleStruct aPojo = new ExampleStruct("Hello world!", 256); IonValue ionStruct; try { // Use the mapper to convert Java objects into Ion ionStruct = ionMapper.writeValueAsIonValue(aPojo); } catch (IOException e) { // Wrap the exception and throw it for the sake of simplicity in this example throw new RuntimeException(e); } // Insertion into QLDB txn.execute("INSERT INTO ExampleTable ?", ionStruct); // Fetching from QLDB Result result = txn.execute("SELECT * from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Use the mapper to convert Ion to Java objects try { aPojo = ionMapper.readValue(ionValue, ExampleStruct.class); } catch (IOException e) { // Wrap the exception and throw it for the sake of simplicity in this example throw new RuntimeException(e); } } // examplePojo is now the document fetched from QLDB return aPojo; });
.NET

UsarAmazon.qldb.driver.serializaciónbiblioteca para asignar tipos de datos nativos de C# desde y hacia Ion. La biblioteca admite los demás tipos de datos de Ion, pero este ejemplo se centra en elstruct.

using Amazon.QLDB.Driver.Generic; using Amazon.QLDB.Driver.Serialization; ... IAsyncQldbDriver driver = AsyncQldbDriver.Builder() .WithLedger("vehicle-registration") // Add Serialization library .WithSerializer(new ObjectSerializer()) .Build(); // Creating a C# POCO. ExampleStruct exampleStruct = new ExampleStruct { ExampleString = "Hello world!", ExampleInt = 256 }; IAsyncResult<ExampleStruct> selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute(txn.Query<Document>("UPDATE ExampleTable SET ExampleStruct = ?", exampleStruct)); // Fetching from QLDB. return await txn.Execute(txn.Query<ExampleStruct>("SELECT VALUE ExampleStruct from ExampleTable")); }); await foreach (ExampleStruct row in selectResult) { Console.WriteLine(row.ExampleString); Console.WriteLine(row.ExampleInt); }
nota

Para convertir en código síncrono, elimine elawaityasyncpalabras clave y cambie laIAsyncResultescriba aIResult.

También puede utilizar laAmazon.IonDotnet.Constructoresbiblioteca para procesar tipos de datos Ion.

using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Creating Ion struct. IIonValue ionStruct = valueFactory.NewEmptyStruct(); ionStruct.SetField("ExampleString", valueFactory.NewString("Hello world!")); ionStruct.SetField("ExampleInt", valueFactory.NewInt(256)); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleStruct = ?", ionStruct); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleStruct from ExampleTable"); }); string retrievedString = null; int? retrievedInt = null; await foreach (IIonValue ionValue in selectResult) { retrievedString = ionValue.GetField("ExampleString").StringValue; retrievedInt = ionValue.GetField("ExampleInt").IntValue; }
Go
exampleStruct, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aStruct := map[string]interface{} { "ExampleString": "Hello World!", "ExampleInt": 256, } // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleStruct = ?", aStruct) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleStruct FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult map[string]interface{} err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleStruct is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonStruct(driver: QldbDriver): Promise<any> { let exampleStruct: any = {stringValue: "Hello World!", intValue: 256}; return (driver.executeLambda(async (txn: TransactionExecutor) => { // Inserting into QLDB await txn.execute("INSERT INTO ExampleTable ?", exampleStruct); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT * FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // We can get all the keys of Ion struct and their associated values const ionFieldNames: string[] = ionValue.fieldNames(); // Getting key and value of Ion struct to TypeScript String and Number const nativeStringVal: string = ionValue.get(ionFieldNames[0]).stringValue(); const nativeIntVal: number = ionValue.get(ionFieldNames[1]).numberValue(); // Alternatively, we can access to Ion struct fields, using their literal field names: // const nativeStringVal = ionValue.get("stringValue").stringValue(); // const nativeIntVal = ionValue.get("intValue").numberValue(); exampleStruct = {[ionFieldNames[0]]: nativeStringVal, [ionFieldNames[1]]: nativeIntVal}; return exampleStruct; }) ); }
Python
def update_and_query_ion_struct(txn): # QLDB can take in a Python struct a_struct = {"ExampleString": "Hello world!", "ExampleInt": 256} # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleStruct = ?", a_struct) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleStruct FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python struct is a child class of Python struct a_struct = ion_value # example_struct is now the value fetched from QLDB return a_struct example_struct = driver.execute_lambda(lambda txn: update_and_query_ion_struct(txn))

Valores nulos y tipos dinámicos

QLDB admite contenido abierto y no aplica definiciones de esquemas o tipos de datos para los campos de documento. También puede almacenar valores nulos de Ion en un documento QLDB. Todos los ejemplos anteriores suponen que cada tipo de datos devuelto se conoce y no es nulo. En los siguientes ejemplos, se muestra cómo trabajar con Ion cuando no se conoce el tipo de datos o es posible que sea nulo.

Java
// Empty variables String exampleString = null; Integer exampleInt = null; // Assume ionValue is some queried data from QLDB IonValue ionValue = null; // Check the value type and assign it to the variable if it is not null if (ionValue.getType() == IonType.STRING) { if (ionValue.isNullValue()) { exampleString = null; } else { exampleString = ((IonString)ionValue).stringValue(); } } else if (ionValue.getType() == IonType.INT) { if (ionValue.isNullValue()) { exampleInt = null; } else { exampleInt = ((IonInt)ionValue).intValue(); } }; // Creating null values IonSystem ionSystem = IonSystemBuilder.standard().build(); // A null value still has an Ion type IonString ionString; if (exampleString == null) { // Specifically a null string ionString = ionSystem.newNullString(); } else { ionString = ionSystem.newString(exampleString); } IonInt ionInt; if (exampleInt == null) { // Specifically a null int ionInt = ionSystem.newNullInt(); } else { ionInt = ionSystem.newInt(exampleInt); } // Special case regarding null! // There is a generic null type which has Ion type 'Null'. // The above null values still have the types 'String' and 'Int' IonValue specialNull = ionSystem.newNull(); if (specialNull.getType() == IonType.NULL) { // This is true! } if (specialNull.isNullValue()) { // This is also true! } if (specialNull.getType() == IonType.STRING || specialNull.getType() == IonType.INT) { // This is false! }
.NET
// Empty variables. string exampleString = null; int? exampleInt = null; // Assume ionValue is some queried data from QLDB. IIonValue ionValue; if (ionValue.Type() == IonType.String) { exampleString = ionValue.StringValue; } else if (ionValue.Type() == IonType.Int) { if (ionValue.IsNull) { exampleInt = null; } else { exampleInt = ionValue.IntValue; } }; // Creating null values. IValueFactory valueFactory = new ValueFactory(); // A null value still has an Ion type. IIonValue ionString = valueFactory.NewString(exampleString); IIonValue ionInt; if (exampleInt == null) { // Specifically a null int. ionInt = valueFactory.NewNullInt(); } else { ionInt = valueFactory.NewInt(exampleInt.Value); } // Special case regarding null! // There is a generic null type which has Ion type 'Null'. IIonValue specialNull = valueFactory.NewNull(); if (specialNull.Type() == IonType.Null) { // This is true! } if (specialNull.IsNull) { // This is also true! }
Go

Limitaciones de marshalling

En Go,nillos valores no conservan su tipo cuando los agrupa y luego los desmonta. UNAnilvalores marshals a Ion null, pero Ion null anulará a un valor cero en lugar denil.

ionNull, err := ion.MarshalText(nil) // ionNull is set to ion null if err != nil { return } var result int err = ion.Unmarshal(ionNull, &result) // result unmarshals to 0 if err != nil { return }
Node.js
// Empty variables let exampleString: string; let exampleInt: number; // Assume ionValue is some queried data from QLDB // Check the value type and assign it to the variable if it is not null if (ionValue.getType() === IonTypes.STRING) { if (ionValue.isNull()) { exampleString = null; } else { exampleString = ionValue.stringValue(); } } else if (ionValue.getType() === IonTypes.INT) { if (ionValue.isNull()) { exampleInt = null; } else { exampleInt = ionValue.numberValue(); } } // Creating null values if (exampleString === null) { ionString = dom.load('null.string'); } else { ionString = dom.load.of(exampleString); } if (exampleInt === null) { ionInt = dom.load('null.int'); } else { ionInt = dom.load.of(exampleInt); } // Special case regarding null! // There is a generic null type which has Ion type 'Null'. // The above null values still have the types 'String' and 'Int' specialNull: dom.Value = dom.load("null.null"); if (specialNull.getType() === IonType.NULL) { // This is true! } if (specialNull.getType() === IonType.STRING || specialNull.getType() === IonType.INT) { // This is false! }
Python
# Empty variables example_string = None example_int = None # Assume ion_value is some queried data from QLDB # Check the value type and assign it to the variable if it is not null if ion_value.ion_type == IonType.STRING: if isinstance(ion_value, IonPyNull): example_string = None else: example_string = ion_value elif ion_value.ion_type == IonType.INT: if isinstance(ion_value, IonPyNull): example_int = None else: example_int = ion_value # Creating Ion null values if example_string is None: # Specifically a null string ion_string = loads("null.string") else: # QLDB can take in Python string ion_string = example_string if example_int is None: # Specifically a null int ion_int = loads("null.int") else: # QLDB can take in Python int ion_int = example_int # Special case regarding null! # There is a generic null type which has Ion type 'Null'. # The above null values still have the types 'String' and 'Int' special_null = loads("null.null") if special_null.ion_type == IonType.NULL: # This is true! if special_null.ion_type == IonType.STRING or special_null.ion_type == IonType.INT: # This is false!

Conversión descendente a JSON

Si tu aplicación requiere compatibilidad JSON, puedes convertir los datos de Amazon Ion a JSON. Sin embargo, la conversión de Ion a JSON tiene pérdidas en algunos casos en los que sus datos aprovechan los tipos de iones enriquecidos que no existen en JSON.

Para obtener más información sobre las reglas de conversión de Ion a JSON, consulteConversión descendente a JSONen laLibro de cocina de Amazon Ion.