Controlador Amazon QLDB para Node.js: libro de recetas de referencia - 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.

Controlador Amazon QLDB para Node.js: libro de recetas de referencia

Esta guía de referencia muestra los casos de uso más comunes del controlador Amazon QLDB para Node.js. En él se proporcionan ejemplos de código JavaScript y TypeScript que muestran cómo utilizar el controlador para ejecutar operaciones básicas de creación, lectura, actualización y eliminación (CRUD, por sus siglas en inglés). También incluye ejemplos de código para procesar datos de Amazon Ion. Además, esta guía destaca las mejores prácticas para hacer que las transacciones sean idempotentes e implementar restricciones de exclusividad.

Importación del controlador

En los ejemplos de código se utilizan las siguientes importaciones.

JavaScript
var qldb = require('amazon-qldb-driver-nodejs'); var ionjs = require('ion-js');
TypeScript
import { QldbDriver, TransactionExecutor } from "amazon-qldb-driver-nodejs"; import { dom, dumpBinary, load } from "ion-js";
nota

En este ejemplo también se importa el paquete Amazon Ion (ion-js). Necesita este paquete para procesar los datos de Ion al ejecutar algunas operaciones de datos de esta referencia. Para obtener más información, consulte Trabajar con Amazon Ion.

Instanciación del controlador

En el siguiente ejemplo de código, se crea una instancia del controlador que se conecta a un nombre de libro mayor especificado mediante la configuración predeterminada.

JavaScript
const qldbDriver = new qldb.QldbDriver("vehicle-registration");
TypeScript
const qldbDriver: QldbDriver = new QldbDriver("vehicle-registration");

Operaciones CRUD

La QLDB ejecuta operaciones de creación, lectura, actualización y eliminación (CRUD, por sus siglas en inglés) como parte de una transacción.

aviso

Como práctica recomendada, haga que sus transacciones de escritura sean estrictamente idempotentes.

Hacer que las transacciones sean idempotentes

Le recomendamos que haga que las transacciones de escritura sean idempotentes para evitar cualquier efecto secundario inesperado en caso de reintentos. Una transacción es idempotente si puede ejecutarse varias veces y producir resultados idénticos cada vez.

Por ejemplo, pensemos en una transacción que inserta un documento en una tabla llamada Person. La transacción debe comprobar primero si el documento ya existe o no en la tabla. Sin esta comprobación, la tabla podría terminar con documentos duplicados.

Supongamos que la QLDB confirma correctamente la transacción en el lado del servidor pero el cliente agota el tiempo de espera mientras espera una respuesta. Si la transacción no es idempotente, se podría insertar el mismo documento más de una vez en caso de volver a intentarlo.

Uso de índices para evitar escanear tablas completas

También le recomendamos que ejecute instrucciones con una frase de predicado WHERE utilizando un operador de igualdad sobre un campo indexado o un ID de documento; por ejemplo, WHERE indexedField = 123 o WHERE indexedField IN (456, 789). Sin esta búsqueda indexada, la QLDB necesita escanear las tablas, lo que puede provocar tiempos de espera de las transacciones o conflictos de control de concurrencia optimista (OCC).

Para obtener más información acerca de OCC, consulte Modelo de concurrencia de Amazon QLDB.

Transacciones creadas de forma implícita

La función QldbDriver.executeLambda acepta una función de Lambda que recibe una instancia de TransactionExecutor, que se puede utilizar para ejecutar instrucciones. La instancia de TransactionExecutor envuelve una transacción creada de forma implícita.

Puede ejecutar instrucciones dentro de la función de Lambda mediante el método execute de transacciones. El controlador confirma implícitamente la transacción cuando vuelve la función de Lambda.

nota

El método execute admite valores tanto en los tipos de Amazon Ion como en los tipos nativos de Node.js. Si pasa un tipo nativo de Node.js como argumento a execute, el controlador lo convierte en un tipo Ion mediante el paquete ion-js (siempre que se admita la conversión para el tipo de datos Node.js indicado). Para conocer los tipos de datos y las reglas de conversión compatibles, consulte el README del DOM de Ion JavaScript.

En las siguientes secciones se muestra cómo ejecutar operaciones CRUD básicas, especificar una lógica de reintento personalizada e implementar restricciones de exclusividad.

Creación de tablas

JavaScript
(async function() { await qldbDriver.executeLambda(async (txn) => { await txn.execute("CREATE TABLE Person"); }); })();
TypeScript
(async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { await txn.execute('CREATE TABLE Person'); }); }());

Creación de índices

JavaScript
(async function() { await qldbDriver.executeLambda(async (txn) => { await txn.execute("CREATE INDEX ON Person (GovId)"); }); })();
TypeScript
(async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { await txn.execute('CREATE INDEX ON Person (GovId)'); }); }());

Lectura de documentos

JavaScript
(async function() { // Assumes that Person table has documents as follows: // { "GovId": "TOYENC486FH", "FirstName": "Brent" } await qldbDriver.executeLambda(async (txn) => { const results = (await txn.execute("SELECT * FROM Person WHERE GovId = 'TOYENC486FH'")).getResultList(); for (let result of results) { console.log(result.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(result.get('FirstName')); // prints [String: 'Brent'] } }); }());
TypeScript
(async function(): Promise<void> { // Assumes that Person table has documents as follows: // { "GovId": "TOYENC486FH", "FirstName": "Brent" } await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { const results: dom.Value[] = (await txn.execute("SELECT * FROM Person WHERE GovId = 'TOYENC486FH'")).getResultList(); for (let result of results) { console.log(result.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(result.get('FirstName')); // prints [String: 'Brent'] } }); }());

Uso de parámetros de consulta

En el siguiente ejemplo de código, se utiliza un parámetro de consulta de tipo nativo.

JavaScript
(async function() { // Assumes that Person table has documents as follows: // { "GovId": "TOYENC486FH", "FirstName": "Brent" } await qldbDriver.executeLambda(async (txn) => { const results = (await txn.execute('SELECT * FROM Person WHERE GovId = ?', 'TOYENC486FH')).getResultList(); for (let result of results) { console.log(result.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(result.get('FirstName')); // prints [String: 'Brent'] } }); }());
TypeScript
(async function(): Promise<void> { // Assumes that Person table has documents as follows: // { "GovId": "TOYENC486FH", "FirstName": "Brent" } await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { const results: dom.Value[] = (await txn.execute('SELECT * FROM Person WHERE GovId = ?', 'TOYENC486FH')).getResultList(); for (let result of results) { console.log(result.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(result.get('FirstName')); // prints [String: 'Brent'] } }); }());

En el siguiente ejemplo de código, se utiliza un parámetro de consulta de tipo Ion.

JavaScript
(async function() { await qldbDriver.executeLambda(async (txn) => { const govId = ionjs.load("TOYENC486FH"); const results = (await txn.execute('SELECT * FROM Person WHERE GovId = ?', govId)).getResultList(); for (let result of results) { console.log(result.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(result.get('FirstName')); // prints [String: 'Brent'] } }); }());
TypeScript
(async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { const govId: dom.Value = load("TOYENC486FH"); const results: dom.Value[] = (await txn.execute('SELECT * FROM Person WHERE GovId = ?', govId)).getResultList(); for (let result of results) { console.log(result.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(result.get('FirstName')); // prints [String: 'Brent'] } }); }());

En el siguiente ejemplo de código se utilizan varios parámetros de consulta.

JavaScript
(async function() { await qldbDriver.executeLambda(async (txn) => { const results = (await txn.execute('SELECT * FROM Person WHERE GovId = ? AND FirstName = ?', 'TOYENC486FH', 'Brent')).getResultList(); for (let result of results) { console.log(result.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(result.get('FirstName')); // prints [String: 'Brent'] } }); }());
TypeScript
(async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { const results: dom.Value[] = (await txn.execute('SELECT * FROM Person WHERE GovId = ? AND FirstName = ?', 'TOYENC486FH', 'Brent')).getResultList(); for (let result of results) { console.log(result.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(result.get('FirstName')); // prints [String: 'Brent'] } }); }());

En el siguiente ejemplo de código, se utiliza una lista de parámetros de consulta.

JavaScript
(async function() { await qldbDriver.executeLambda(async (txn) => { const govIds = ['TOYENC486FH','LOGANB486CG','LEWISR261LL']; /* Assumes that Person table has documents as follows: { "GovId": "TOYENC486FH", "FirstName": "Brent" } { "GovId": "LOGANB486CG", "FirstName": "Brent" } { "GovId": "LEWISR261LL", "FirstName": "Raul" } */ const results = (await txn.execute('SELECT * FROM Person WHERE GovId IN (?,?,?)', ...govIds)).getResultList(); for (let result of results) { console.log(result.get('GovId')); console.log(result.get('FirstName')); /* prints: [String: 'TOYENC486FH'] [String: 'Brent'] [String: 'LOGANB486CG'] [String: 'Brent'] [String: 'LEWISR261LL'] [String: 'Raul'] */ } }); }());
TypeScript
(async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { const govIds: string[] = ['TOYENC486FH','LOGANB486CG','LEWISR261LL']; /* Assumes that Person table has documents as follows: { "GovId": "TOYENC486FH", "FirstName": "Brent" } { "GovId": "LOGANB486CG", "FirstName": "Brent" } { "GovId": "LEWISR261LL", "FirstName": "Raul" } */ const results: dom.Value[] = (await txn.execute('SELECT * FROM Person WHERE GovId IN (?,?,?)', ...govIds)).getResultList(); for (let result of results) { console.log(result.get('GovId')); console.log(result.get('FirstName')); /* prints: [String: 'TOYENC486FH'] [String: 'Brent'] [String: 'LOGANB486CG'] [String: 'Brent'] [String: 'LEWISR261LL'] [String: 'Raul'] */ } }); }());
nota

Cuando ejecuta una consulta sin una búsqueda indexada, se invoca un escaneo completo de la tabla. En este ejemplo, se recomienda tener un índice en el campo GovId para optimizar el rendimiento. Sin un índice en GovId, las consultas pueden tener más latencia y, además, provocar excepciones de conflictos de OCC o tiempos de espera de las transacciones.

Inserción de documentos

El siguiente ejemplo de código inserta los tipos de datos nativos.

JavaScript
(async function() { await qldbDriver.executeLambda(async (txn) => { // Check if doc with GovId:TOYENC486FH exists // This is critical to make this transaction idempotent const results = (await txn.execute('SELECT * FROM Person WHERE GovId = ?', 'TOYENC486FH')).getResultList(); // Insert the document after ensuring it doesn't already exist if (results.length == 0) { const doc = { 'FirstName': 'Brent', 'GovId': 'TOYENC486FH', }; await txn.execute('INSERT INTO Person ?', doc); } }); }());
TypeScript
(async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { // Check if doc with GovId:TOYENC486FH exists // This is critical to make this transaction idempotent const results: dom.Value[] = (await txn.execute('SELECT * FROM Person WHERE GovId = ?', 'TOYENC486FH')).getResultList(); // Insert the document after ensuring it doesn't already exist if (results.length == 0) { const doc: Record<string, string> = { 'FirstName': 'Brent', 'GovId': 'TOYENC486FH', }; await txn.execute('INSERT INTO Person ?', doc); } }); }());

El siguiente ejemplo de código inserta los tipos de datos de Ion.

JavaScript
(async function() { await qldbDriver.executeLambda(async (txn) => { // Check if doc with GovId:TOYENC486FH exists // This is critical to make this transaction idempotent const results = (await txn.execute('SELECT * FROM Person WHERE GovId = ?', 'TOYENC486FH')).getResultList(); // Insert the document after ensuring it doesn't already exist if (results.length == 0) { const doc = { 'FirstName': 'Brent', 'GovId': 'TOYENC486FH', }; // Create a sample Ion doc const ionDoc = ionjs.load(ionjs.dumpBinary(doc)); await txn.execute('INSERT INTO Person ?', ionDoc); } }); }());
TypeScript
(async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { // Check if doc with GovId:TOYENC486FH exists // This is critical to make this transaction idempotent const results: dom.Value[] = (await txn.execute('SELECT * FROM Person WHERE GovId = ?', 'TOYENC486FH')).getResultList(); // Insert the document after ensuring it doesn't already exist if (results.length == 0) { const doc: Record<string, string> = { 'FirstName': 'Brent', 'GovId': 'TOYENC486FH', }; // Create a sample Ion doc const ionDoc: dom.Value = load(dumpBinary(doc)); await txn.execute('INSERT INTO Person ?', ionDoc); } }); }());

Esta transacción inserta un documento en la tabla Person. Antes de insertar, compruebe primero si el documento ya existe en la tabla. Esta comprobación hace que la transacción sea de naturaleza idempotente. Incluso si realiza esta transacción varias veces, no provocará ningún efecto secundario no deseado.

nota

En este ejemplo, se recomienda tener un índice en el campo GovId para optimizar el rendimiento. Sin un índice en GovId, las instrucciones pueden tener más latencia y, además, provocar excepciones de conflictos de OCC o tiempos de espera de las transacciones.

Insertar varios documentos en una instrucción

Para insertar varios documentos mediante una sola instrucción INSERT, puede pasar un parámetro del tipo list a la instrucción de la siguiente manera.

// people is a list txn.execute("INSERT INTO People ?", people);

No coloque el marcador de posición variable (?) entre corchetes de doble ángulo (<<...>>) al pasar una lista. En las instrucciones PartiQL manuales, los corchetes de doble ángulo indican una colección desordenada conocida como bolsa.

Actualización de documentos

El siguiente ejemplo de código utiliza tipos de datos nativos.

JavaScript
(async function() { await qldbDriver.executeLambda(async (txn) => { await txn.execute('UPDATE Person SET FirstName = ? WHERE GovId = ?', 'John', 'TOYENC486FH'); }); }());
TypeScript
(async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { await txn.execute('UPDATE Person SET FirstName = ? WHERE GovId = ?', 'John', 'TOYENC486FH'); }); }());

El siguiente ejemplo de código utiliza tipos de datos Ion.

JavaScript
(async function() { await qldbDriver.executeLambda(async (txn) => { const firstName = ionjs.load("John"); const govId = ionjs.load("TOYENC486FH"); await txn.execute('UPDATE Person SET FirstName = ? WHERE GovId = ?', firstName, govId); }); }());
TypeScript
(async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { const firstName: dom.Value = load("John"); const govId: dom.Value = load("TOYENC486FH"); await txn.execute('UPDATE Person SET FirstName = ? WHERE GovId = ?', firstName, govId); }); }());
nota

En este ejemplo, se recomienda tener un índice en el campo GovId para optimizar el rendimiento. Sin un índice en GovId, las instrucciones pueden tener más latencia y, además, provocar excepciones de conflictos de OCC o tiempos de espera de las transacciones.

Eliminación de documentos

El siguiente ejemplo de código utiliza tipos de datos nativos.

JavaScript
(async function() { await qldbDriver.executeLambda(async (txn) => { await txn.execute('DELETE FROM Person WHERE GovId = ?', 'TOYENC486FH'); }); }());
TypeScript
(async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { await txn.execute('DELETE FROM Person WHERE GovId = ?', 'TOYENC486FH'); }); }());

El siguiente ejemplo de código utiliza tipos de datos Ion.

JavaScript
(async function() { await qldbDriver.executeLambda(async (txn) => { const govId = ionjs.load("TOYENC486FH"); await txn.execute('DELETE FROM Person WHERE GovId = ?', govId); }); }());
TypeScript
(async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { const govId: dom.Value = load("TOYENC486FH"); await txn.execute('DELETE FROM Person WHERE GovId = ?', govId); }); }());
nota

En este ejemplo, se recomienda tener un índice en el campo GovId para optimizar el rendimiento. Sin un índice en GovId, las instrucciones pueden tener más latencia y, además, provocar excepciones de conflictos de OCC o tiempos de espera de las transacciones.

Ejecutar varias instrucciones en una transacción

TypeScript
// This code snippet is intentionally trivial. In reality you wouldn't do this because you'd // set your UPDATE to filter on vin and insured, and check if you updated something or not. async function insureCar(driver: QldbDriver, vin: string): Promise<boolean> { return await driver.executeLambda(async (txn: TransactionExecutor) => { const results: dom.Value[] = (await txn.execute( "SELECT insured FROM Vehicles WHERE vin = ? AND insured = FALSE", vin)).getResultList(); if (results.length > 0) { await txn.execute( "UPDATE Vehicles SET insured = TRUE WHERE vin = ?", vin); return true; } return false; }); };

Lógica de reintentos

El método del controlador executeLambda tiene un mecanismo de reintento integrado que reintenta la transacción si se produce una excepción que se pueda volver a intentar (como tiempos de espera o conflictos de OCC). El número máximo de reintentos y la estrategia de retardo se pueden configurar.

El límite de reintentos predeterminado es 4 y la estrategia de retardo predeterminada es defaultBackoffFunction, con una base de 10 milisegundos. Puede establecer la configuración de reintentos por instancia de controlador y también por transacción mediante una instancia de RetryConfig.

El siguiente ejemplo de código especifica la lógica de reintentos con un límite de reintentos personalizado y una estrategia de retardo personalizada para una instancia del controlador.

JavaScript
var qldb = require('amazon-qldb-driver-nodejs'); // Configuring retry limit to 2 const retryConfig = new qldb.RetryConfig(2); const qldbDriver = new qldb.QldbDriver("test-ledger", undefined, undefined, retryConfig); // Configuring a custom backoff which increases delay by 1s for each attempt. const customBackoff = (retryAttempt, error, transactionId) => { return 1000 * retryAttempt; }; const retryConfigCustomBackoff = new qldb.RetryConfig(2, customBackoff); const qldbDriverCustomBackoff = new qldb.QldbDriver("test-ledger", undefined, undefined, retryConfigCustomBackoff);
TypeScript
import { BackoffFunction, QldbDriver, RetryConfig } from "amazon-qldb-driver-nodejs" // Configuring retry limit to 2 const retryConfig: RetryConfig = new RetryConfig(2); const qldbDriver: QldbDriver = new QldbDriver("test-ledger", undefined, undefined, retryConfig); // Configuring a custom backoff which increases delay by 1s for each attempt. const customBackoff: BackoffFunction = (retryAttempt: number, error: Error, transactionId: string) => { return 1000 * retryAttempt; }; const retryConfigCustomBackoff: RetryConfig = new RetryConfig(2, customBackoff); const qldbDriverCustomBackoff: QldbDriver = new QldbDriver("test-ledger", undefined, undefined, retryConfigCustomBackoff);

El siguiente ejemplo de código especifica la lógica de reintentos con un límite de reintentos personalizado y una estrategia de retardo personalizada para una ejecución lambda particular. Esta configuración executeLambda anula la lógica de reintentos establecida para la instancia del controlador.

JavaScript
var qldb = require('amazon-qldb-driver-nodejs'); // Configuring retry limit to 2 const retryConfig1 = new qldb.RetryConfig(2); const qldbDriver = new qldb.QldbDriver("test-ledger", undefined, undefined, retryConfig1); // Configuring a custom backoff which increases delay by 1s for each attempt. const customBackoff = (retryAttempt, error, transactionId) => { return 1000 * retryAttempt; }; const retryConfig2 = new qldb.RetryConfig(2, customBackoff); // The config `retryConfig1` will be overridden by `retryConfig2` (async function() { await qldbDriver.executeLambda(async (txn) => { await txn.execute('CREATE TABLE Person'); }, retryConfig2); }());
TypeScript
import { BackoffFunction, QldbDriver, RetryConfig, TransactionExecutor } from "amazon-qldb-driver-nodejs" // Configuring retry limit to 2 const retryConfig1: RetryConfig = new RetryConfig(2); const qldbDriver: QldbDriver = new QldbDriver("test-ledger", undefined, undefined, retryConfig1); // Configuring a custom backoff which increases delay by 1s for each attempt. const customBackoff: BackoffFunction = (retryAttempt: number, error: Error, transactionId: string) => { return 1000 * retryAttempt; }; const retryConfig2: RetryConfig = new RetryConfig(2, customBackoff); // The config `retryConfig1` will be overridden by `retryConfig2` (async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { await txn.execute('CREATE TABLE Person'); }, retryConfig2); }());

Implementación de restricciones de exclusividad

QLDB no admite índices únicos, pero puede implementar este comportamiento en su aplicación.

Suponga que desea implementar una restricción de exclusividad en el campo GovId de la tabla Person. Para ello, puede escribir una transacción que haga lo siguiente:

  1. Afirmar que en la tabla no hay documentos existentes con un GovId especificado.

  2. Insertar el documento si se aprueba la afirmación.

Si una transacción competidora supera la afirmación simultáneamente, solo una de las transacciones se confirmará correctamente. La otra transacción fallará y se producirá una excepción de conflicto de OCC.

En el siguiente ejemplo de código, se muestra cómo implementar esta lógica de restricción de exclusividad.

JavaScript
const govId = 'TOYENC486FH'; const document = { 'FirstName': 'Brent', 'GovId': 'TOYENC486FH', }; (async function() { await qldbDriver.executeLambda(async (txn) => { // Check if doc with GovId = govId exists const results = (await txn.execute('SELECT * FROM Person WHERE GovId = ?', govId)).getResultList(); // Insert the document after ensuring it doesn't already exist if (results.length == 0) { await txn.execute('INSERT INTO Person ?', document); } }); })();
TypeScript
const govId: string = 'TOYENC486FH'; const document: Record<string, string> = { 'FirstName': 'Brent', 'GovId': 'TOYENC486FH', }; (async function(): Promise<void> { await qldbDriver.executeLambda(async (txn: TransactionExecutor) => { // Check if doc with GovId = govId exists const results: dom.Value[] = (await txn.execute('SELECT * FROM Person WHERE GovId = ?', govId)).getResultList(); // Insert the document after ensuring it doesn't already exist if (results.length == 0) { await txn.execute('INSERT INTO Person ?', document); } }); })();
nota

En este ejemplo, se recomienda tener un índice en el campo GovId para optimizar el rendimiento. Sin un índice en GovId, las instrucciones pueden tener más latencia y, además, provocar excepciones de conflictos de OCC o tiempos de espera de las transacciones.

Trabajar con Amazon Ion

Las siguientes secciones muestran cómo usar el módulo Amazon Ion para procesar los datos de Ion.

Importación del módulo Ion

JavaScript
var ionjs = require('ion-js');
TypeScript
import { dom, dumpBinary, dumpText, load } from "ion-js";

Creación de tipos de Ion

El siguiente ejemplo de código crea un objeto Ion a partir del texto de Ion.

JavaScript
const ionText = '{GovId: "TOYENC486FH", FirstName: "Brent"}'; const ionObj = ionjs.load(ionText); console.log(ionObj.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(ionObj.get('FirstName')); // prints [String: 'Brent']
TypeScript
const ionText: string = '{GovId: "TOYENC486FH", FirstName: "Brent"}'; const ionObj: dom.Value = load(ionText); console.log(ionObj.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(ionObj.get('FirstName')); // prints [String: 'Brent']

El siguiente ejemplo de código crea un objeto Ion a partir del diccionario de Node.js.

JavaScript
const aDict = { 'GovId': 'TOYENC486FH', 'FirstName': 'Brent' }; const ionObj = ionjs.load(ionjs.dumpBinary(aDict)); console.log(ionObj.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(ionObj.get('FirstName')); // prints [String: 'Brent']
TypeScript
const aDict: Record<string, string> = { 'GovId': 'TOYENC486FH', 'FirstName': 'Brent' }; const ionObj: dom.Value = load(dumpBinary(aDict)); console.log(ionObj.get('GovId')); // prints [String: 'TOYENC486FH'] console.log(ionObj.get('FirstName')); // prints [String: 'Brent']

Obtener un volcado binario de Ion

JavaScript
// ionObj is an Ion struct console.log(ionjs.dumpBinary(ionObj).toString()); // prints 224,1,0,234,238,151,129,131,222,147,135,190,144,133,71,111,118,73,100,137,70,105,114,115,116,78,97,109,101,222,148,138,139,84,79,89,69,78,67,52,56,54,70,72,139,133,66,114,101,110,116
TypeScript
// ionObj is an Ion struct console.log(dumpBinary(ionObj).toString()); // prints 224,1,0,234,238,151,129,131,222,147,135,190,144,133,71,111,118,73,100,137,70,105,114,115,116,78,97,109,101,222,148,138,139,84,79,89,69,78,67,52,56,54,70,72,139,133,66,114,101,110,116

Obtener un volcado de texto de Ion

JavaScript
// ionObj is an Ion struct console.log(ionjs.dumpText(ionObj)); // prints {GovId:"TOYENC486FH",FirstName:"Brent"}
TypeScript
// ionObj is an Ion struct console.log(dumpText(ionObj)); // prints {GovId:"TOYENC486FH",FirstName:"Brent"}

Para obtener más información acerca de Ion, consulte la documentación de Amazon Ion en GitHub. Para ver más ejemplos de código sobre cómo trabajar con Ion en QLDB, consulte Uso de tipos de datos de Amazon Ion en Amazon QLDB.