Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Tutorial su Amazon QLDB Node.js
**Importante**
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).
In questa implementazione dell'applicazione di esempio del tutorial, utilizzi il driver Amazon QLDB con AWS l'SDK JavaScript per Node.js per creare un registro QLDB e compilarlo con dati di esempio.
[Mentre segui questo tutorial, puoi fare riferimento all'API Reference per le AWS SDK per JavaScript operazioni API di gestione.](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/) Per le operazioni sui dati transazionali, puoi fare riferimento al QLDB Driver for Node.js API [Reference](https://amazon-qldb-docs.s3.amazonaws.com/drivers/nodejs/3.1.0/index.html).
**Nota**
Ove applicabile, alcuni passaggi del tutorial contengono comandi o esempi di codice diversi per ogni versione principale supportata del driver QLDB per Node.js.
**Topics**
+ [Installazione dell'applicazione di esempio Amazon QLDB Node.js](sample-app.nodejs.md)
+ [Fase 1: Creare un nuovo libro mastro](getting-started.nodejs.step-1.md)
+ [Passaggio 2: verifica la connettività al registro](getting-started.nodejs.step-2.md)
+ [Passaggio 3: Creare tabelle, indici e dati di esempio](getting-started.nodejs.step-3.md)
+ [Passaggio 4: interrogare le tabelle in un libro mastro](getting-started.nodejs.step-4.md)
+ [Fase 5: Modificare i documenti in un libro mastro](getting-started.nodejs.step-5.md)
+ [Fase 6: Visualizzare la cronologia delle revisioni di un documento](getting-started.nodejs.step-6.md)
+ [Fase 7: Verificare un documento in un libro mastro](getting-started.nodejs.step-7.md)
+ [Passaggio 8 (opzionale): Pulisci le risorse](getting-started.nodejs.step-8.md)
# Installazione dell'applicazione di esempio Amazon QLDB Node.js
**Importante**
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).
Questa sezione descrive come installare ed eseguire l'applicazione di esempio Amazon QLDB fornita per step-by-step il tutorial Node.js. Il caso d'uso di questa applicazione di esempio è un database del Dipartimento dei veicoli a motore (DMV) che tiene traccia delle informazioni storiche complete sulle immatricolazioni dei veicoli.
[L'applicazione di esempio DMV per Node.js è open source nel GitHub repository aws-samples/ -nodejs. amazon-qldb-dmv-sample](https://github.com/aws-samples/amazon-qldb-dmv-sample-nodejs)
## Prerequisiti
Prima di iniziare, assicurati di aver completato il driver QLDB per Node.js. [Prerequisiti](getting-started.nodejs.md#getting-started.nodejs.prereqs) Ciò include l'installazione di Node.js e le seguenti operazioni:
1. Registrati per AWS.
1. Crea un utente con le autorizzazioni QLDB appropriate.
1. Concedi l'accesso programmatico per lo sviluppo.
Per completare tutti i passaggi di questo tutorial, è necessario l'accesso amministrativo completo alla risorsa di registro tramite l'API QLDB.
## Installazione
**Per installare l'applicazione di esempio**
1. Immettete il seguente comando da cui clonare l'applicazione di GitHub esempio.
------
#### [ 2.x ]
```
git clone https://github.com/aws-samples/amazon-qldb-dmv-sample-nodejs.git
```
------
#### [ 1.x ]
```
git clone -b v1.0.0 https://github.com/aws-samples/amazon-qldb-dmv-sample-nodejs.git
```
------
L'applicazione di esempio racchiude il codice sorgente completo di questo tutorial e le relative dipendenze, inclusi il driver Node.js e l'[AWS SDK per JavaScript Node.js](https://aws.amazon.com/sdk-for-node-js). Questa applicazione è scritta in. TypeScript
1. Passa alla directory in cui viene clonato il `amazon-qldb-dmv-sample-nodejs` pacchetto.
```
cd amazon-qldb-dmv-sample-nodejs
```
1. Esegui un'installazione pulita delle dipendenze.
```
npm ci
```
1. Transpila il pacchetto.
```
npm run build
```
I JavaScript file transpilati vengono scritti nella directory. `./dist`
1. Procedi con l'[Fase 1: Creare un nuovo libro mastro](getting-started.nodejs.step-1.md)avvio del tutorial e la creazione di un libro mastro.
# Fase 1: Creare un nuovo libro mastro
**Importante**
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).
In questo passaggio, crei un nuovo registro Amazon QLDB denominato. `vehicle-registration`
**Per creare un nuovo libro mastro**
1. Esamina il seguente file (`Constants.ts`), che contiene valori costanti utilizzati da tutti gli altri programmi di questo tutorial.
```
/*
* 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.
*/
/**
* Constant values used throughout this tutorial.
*/
export const LEDGER_NAME = "vehicle-registration";
export const LEDGER_NAME_WITH_TAGS = "tags";
export const DRIVERS_LICENSE_TABLE_NAME = "DriversLicense";
export const PERSON_TABLE_NAME = "Person";
export const VEHICLE_REGISTRATION_TABLE_NAME = "VehicleRegistration";
export const VEHICLE_TABLE_NAME = "Vehicle";
export const GOV_ID_INDEX_NAME = "GovId";
export const LICENSE_NUMBER_INDEX_NAME = "LicenseNumber";
export const LICENSE_PLATE_NUMBER_INDEX_NAME = "LicensePlateNumber";
export const PERSON_ID_INDEX_NAME = "PersonId";
export const VIN_INDEX_NAME = "VIN";
export const RETRY_LIMIT = 4;
export const JOURNAL_EXPORT_S3_BUCKET_NAME_PREFIX = "qldb-tutorial-journal-export";
export const USER_TABLES = "information_schema.user_tables";
```
1. Utilizzate il seguente programma (`CreateLedger.ts`) per creare un registro denominato`vehicle-registration`.
```
/*
* 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 { QLDB } from "aws-sdk";
import {
CreateLedgerRequest,
CreateLedgerResponse,
DescribeLedgerRequest,
DescribeLedgerResponse
} from "aws-sdk/clients/qldb";
import { LEDGER_NAME } from "./qldb/Constants";
import { error, log } from "./qldb/LogUtil";
import { sleep } from "./qldb/Util";
const LEDGER_CREATION_POLL_PERIOD_MS = 10000;
const ACTIVE_STATE = "ACTIVE";
/**
* Create a new ledger with the specified name.
* @param ledgerName Name of the ledger to be created.
* @param qldbClient The QLDB control plane client to use.
* @returns Promise which fulfills with a CreateLedgerResponse.
*/
export async function createLedger(ledgerName: string, qldbClient: QLDB): Promise {
log(`Creating a ledger named: ${ledgerName}...`);
const request: CreateLedgerRequest = {
Name: ledgerName,
PermissionsMode: "ALLOW_ALL"
}
const result: CreateLedgerResponse = await qldbClient.createLedger(request).promise();
log(`Success. Ledger state: ${result.State}.`);
return result;
}
/**
* Wait for the newly created ledger to become active.
* @param ledgerName Name of the ledger to be checked on.
* @param qldbClient The QLDB control plane client to use.
* @returns Promise which fulfills with a DescribeLedgerResponse.
*/
export async function waitForActive(ledgerName: string, qldbClient: QLDB): Promise {
log(`Waiting for ledger ${ledgerName} to become active...`);
const request: DescribeLedgerRequest = {
Name: ledgerName
}
while (true) {
const result: DescribeLedgerResponse = await qldbClient.describeLedger(request).promise();
if (result.State === ACTIVE_STATE) {
log("Success. Ledger is active and ready to be used.");
return result;
}
log("The ledger is still creating. Please wait...");
await sleep(LEDGER_CREATION_POLL_PERIOD_MS);
}
}
/**
* Create a ledger and wait for it to be active.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbClient: QLDB = new QLDB();
await createLedger(LEDGER_NAME, qldbClient);
await waitForActive(LEDGER_NAME, qldbClient);
} catch (e) {
error(`Unable to create the ledger: ${e}`);
}
}
if (require.main === module) {
main();
}
```
**Nota**
Nella `createLedger` chiamata, è necessario specificare un nome di registro e una modalità di autorizzazione. Ti consigliamo di utilizzare la modalità `STANDARD` autorizzazioni per massimizzare la sicurezza dei dati del registro.
Quando si crea un registro, la *protezione da eliminazione* è abilitata per impostazione predefinita. Questa è una funzionalità di QLDB che impedisce l'eliminazione dei registri da parte di qualsiasi utente. Hai la possibilità di disabilitare la protezione da eliminazione durante la creazione del registro utilizzando l'API QLDB o il (). AWS Command Line Interface AWS CLI
Facoltativamente, puoi anche specificare i tag da allegare al tuo registro.
1. Per eseguire il programma transpiled, immettete il seguente comando.
```
node dist/CreateLedger.js
```
Per verificare la connessione al nuovo registro, procedi a. [Passaggio 2: verifica la connettività al registro](getting-started.nodejs.step-2.md)
# Passaggio 2: verifica la connettività al registro
**Importante**
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).
In questo passaggio, verifichi di poterti connettere al `vehicle-registration` registro in Amazon QLDB utilizzando l'endpoint API dei dati transazionali.
**Per testare la connettività al registro**
1. Utilizzate il seguente programma (`ConnectToLedger.ts`) per creare una connessione di sessione dati al `vehicle-registration` registro.
------
#### [ 2.x ]
```
/*
* 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, RetryConfig } from "amazon-qldb-driver-nodejs";
import { ClientConfiguration } from "aws-sdk/clients/qldbsession";
import { LEDGER_NAME } from "./qldb/Constants";
import { error, log } from "./qldb/LogUtil";
const qldbDriver: QldbDriver = createQldbDriver();
/**
* Create a driver for creating sessions.
* @param ledgerName The name of the ledger to create the driver on.
* @param serviceConfigurationOptions The configurations for the AWS SDK client that the driver uses.
* @returns The driver for creating sessions.
*/
export function createQldbDriver(
ledgerName: string = LEDGER_NAME,
serviceConfigurationOptions: ClientConfiguration = {}
): QldbDriver {
const retryLimit = 4;
const maxConcurrentTransactions = 10;
//Use driver's default backoff function (and hence, no second parameter provided to RetryConfig)
const retryConfig: RetryConfig = new RetryConfig(retryLimit);
const qldbDriver: QldbDriver = new QldbDriver(ledgerName, serviceConfigurationOptions, maxConcurrentTransactions, retryConfig);
return qldbDriver;
}
export function getQldbDriver(): QldbDriver {
return qldbDriver;
}
/**
* Connect to a session for a given ledger using default settings.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
log("Listing table names...");
const tableNames: string[] = await qldbDriver.getTableNames();
tableNames.forEach((tableName: string): void => {
log(tableName);
});
} catch (e) {
error(`Unable to create session: ${e}`);
}
}
if (require.main === module) {
main();
}
```
------
#### [ 1.x ]
```
/*
* 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 } from "amazon-qldb-driver-nodejs";
import { ClientConfiguration } from "aws-sdk/clients/qldbsession";
import { LEDGER_NAME } from "./qldb/Constants";
import { error, log } from "./qldb/LogUtil";
const qldbDriver: QldbDriver = createQldbDriver();
/**
* Create a driver for creating sessions.
* @param ledgerName The name of the ledger to create the driver on.
* @param serviceConfigurationOptions The configurations for the AWS SDK client that the driver uses.
* @returns The driver for creating sessions.
*/
export function createQldbDriver(
ledgerName: string = LEDGER_NAME,
serviceConfigurationOptions: ClientConfiguration = {}
): QldbDriver {
const qldbDriver: QldbDriver = new QldbDriver(ledgerName, serviceConfigurationOptions);
return qldbDriver;
}
export function getQldbDriver(): QldbDriver {
return qldbDriver;
}
/**
* Connect to a session for a given ledger using default settings.
* @returns Promise which fulfills with void.
*/
var main = async function(): Promise {
try {
log("Listing table names...");
const tableNames: string[] = await qldbDriver.getTableNames();
tableNames.forEach((tableName: string): void => {
log(tableName);
});
} catch (e) {
error(`Unable to create session: ${e}`);
}
}
if (require.main === module) {
main();
}
```
------
**Nota**
Per eseguire transazioni di dati sul registro, è necessario creare un oggetto driver QLDB per connettersi a un registro specifico. Si tratta di un oggetto client diverso dall'`qldbClient`oggetto utilizzato nel [passaggio precedente](getting-started.nodejs.step-1.md) per creare il registro. Quel client precedente viene utilizzato solo per eseguire le operazioni dell'API di gestione elencate in. [Riferimento all'API Amazon QLDB](api-reference.md)
1. Per eseguire il programma transpiled, immettete il seguente comando.
```
node dist/ConnectToLedger.js
```
Per creare tabelle nel `vehicle-registration` registro, procedi a. [Passaggio 3: Creare tabelle, indici e dati di esempio](getting-started.nodejs.step-3.md)
# Passaggio 3: Creare tabelle, indici e dati di esempio
**Importante**
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).
Quando il tuo registro Amazon QLDB è attivo e accetta connessioni, puoi iniziare a creare tabelle per i dati sui veicoli, i loro proprietari e le loro informazioni di immatricolazione. Dopo aver creato le tabelle e gli indici, puoi caricarli con i dati.
In questo passaggio, crei quattro tabelle nel `vehicle-registration` registro:
+ `VehicleRegistration`
+ `Vehicle`
+ `Person`
+ `DriversLicense`
Vengono inoltre creati i seguenti indici.
****
| Nome tabella | Campo |
| --- | --- |
| VehicleRegistration | VIN |
| VehicleRegistration | LicensePlateNumber |
| Vehicle | VIN |
| Person | GovId |
| DriversLicense | LicenseNumber |
| DriversLicense | PersonId |
Quando si inseriscono dati di esempio, si inseriscono innanzitutto i documenti nella tabella. `Person` Quindi, si utilizzano i dati assegnati `id` dal sistema a ciascun `Person` documento per compilare i campi corrispondenti nei documenti appropriati. `VehicleRegistration` `DriversLicense`
**Suggerimento**
Come procedura ottimale, utilizzate il sistema assegnato a un documento come chiave esterna`id`. Sebbene sia possibile definire campi destinati a essere identificatori univoci (ad esempio, il VIN di un veicolo), il vero identificatore univoco di un documento è il suo. `id` Questo campo è incluso nei metadati del documento, a cui è possibile eseguire una query nella visualizzazione confermata (*la vista* di una tabella definita dal sistema).
Per ulteriori informazioni sulle viste in QLDB, vedere. [Concetti principali](ledger-structure.md) Per ulteriori informazioni sui metadati, consulta. [Interrogazione dei metadati dei documenti](working.metadata.md)
**Per creare tabelle e indici**
1. Utilizzate il seguente programma (`CreateTable.ts`) per creare le tabelle menzionate in precedenza.
```
/*
* 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 { getQldbDriver } from "./ConnectToLedger";
import {
DRIVERS_LICENSE_TABLE_NAME,
PERSON_TABLE_NAME,
VEHICLE_REGISTRATION_TABLE_NAME,
VEHICLE_TABLE_NAME
} from "./qldb/Constants";
import { error, log } from "./qldb/LogUtil";
/**
* Create multiple tables in a single transaction.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param tableName Name of the table to create.
* @returns Promise which fulfills with the number of changes to the database.
*/
export async function createTable(txn: TransactionExecutor, tableName: string): Promise {
const statement: string = `CREATE TABLE ${tableName}`;
return await txn.execute(statement).then((result: Result) => {
log(`Successfully created table ${tableName}.`);
return result.getResultList().length;
});
}
/**
* Create tables in a QLDB ledger.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbDriver: QldbDriver = getQldbDriver();
await qldbDriver.executeLambda(async (txn: TransactionExecutor) => {
Promise.all([
createTable(txn, VEHICLE_REGISTRATION_TABLE_NAME),
createTable(txn, VEHICLE_TABLE_NAME),
createTable(txn, PERSON_TABLE_NAME),
createTable(txn, DRIVERS_LICENSE_TABLE_NAME)
]);
});
} catch (e) {
error(`Unable to create tables: ${e}`);
}
}
if (require.main === module) {
main();
}
```
**Nota**
Questo programma dimostra come utilizzare la `executeLambda` funzione in un'istanza del driver QLDB. In questo esempio, esegui più istruzioni `CREATE TABLE` PartiQL con una singola espressione lambda.
Questa funzione di esecuzione avvia implicitamente una transazione, esegue tutte le istruzioni in lambda e quindi esegue automaticamente il commit della transazione.
1. Per eseguire il programma transpiled, inserisci il seguente comando.
```
node dist/CreateTable.js
```
1. Utilizzate il seguente programma (`CreateIndex.ts`) per creare indici sulle tabelle, come descritto in precedenza.
```
/*
* 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, TransactionExecutor } from "amazon-qldb-driver-nodejs";
import { getQldbDriver } from "./ConnectToLedger";
import {
DRIVERS_LICENSE_TABLE_NAME,
GOV_ID_INDEX_NAME,
LICENSE_NUMBER_INDEX_NAME,
LICENSE_PLATE_NUMBER_INDEX_NAME,
PERSON_ID_INDEX_NAME,
PERSON_TABLE_NAME,
VEHICLE_REGISTRATION_TABLE_NAME,
VEHICLE_TABLE_NAME,
VIN_INDEX_NAME
} from "./qldb/Constants";
import { error, log } from "./qldb/LogUtil";
/**
* Create an index for a particular table.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param tableName Name of the table to add indexes for.
* @param indexAttribute Index to create on a single attribute.
* @returns Promise which fulfills with the number of changes to the database.
*/
export async function createIndex(
txn: TransactionExecutor,
tableName: string,
indexAttribute: string
): Promise {
const statement: string = `CREATE INDEX on ${tableName} (${indexAttribute})`;
return await txn.execute(statement).then((result) => {
log(`Successfully created index ${indexAttribute} on table ${tableName}.`);
return result.getResultList().length;
});
}
/**
* Create indexes on tables in a particular ledger.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbDriver: QldbDriver = getQldbDriver();
await qldbDriver.executeLambda(async (txn: TransactionExecutor) => {
Promise.all([
createIndex(txn, PERSON_TABLE_NAME, GOV_ID_INDEX_NAME),
createIndex(txn, VEHICLE_TABLE_NAME, VIN_INDEX_NAME),
createIndex(txn, VEHICLE_REGISTRATION_TABLE_NAME, VIN_INDEX_NAME),
createIndex(txn, VEHICLE_REGISTRATION_TABLE_NAME, LICENSE_PLATE_NUMBER_INDEX_NAME),
createIndex(txn, DRIVERS_LICENSE_TABLE_NAME, PERSON_ID_INDEX_NAME),
createIndex(txn, DRIVERS_LICENSE_TABLE_NAME, LICENSE_NUMBER_INDEX_NAME)
]);
});
} catch (e) {
error(`Unable to create indexes: ${e}`);
}
}
if (require.main === module) {
main();
}
```
1. Per eseguire il programma transpiled, immettete il seguente comando.
```
node dist/CreateIndex.js
```
**Per caricare i dati nelle tabelle**
1. Esamina i seguenti `.ts` file.
1. `SampleData.ts`— Contiene i dati di esempio che vengono inseriti nelle `vehicle-registration` tabelle.
```
/*
* 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 { Decimal } from "ion-js";
const EMPTY_SECONDARY_OWNERS: object[] = [];
export const DRIVERS_LICENSE = [
{
PersonId: "",
LicenseNumber: "LEWISR261LL",
LicenseType: "Learner",
ValidFromDate: new Date("2016-12-20"),
ValidToDate: new Date("2020-11-15")
},
{
PersonId: "",
LicenseNumber : "LOGANB486CG",
LicenseType: "Probationary",
ValidFromDate : new Date("2016-04-06"),
ValidToDate : new Date("2020-11-15")
},
{
PersonId: "",
LicenseNumber : "744 849 301",
LicenseType: "Full",
ValidFromDate : new Date("2017-12-06"),
ValidToDate : new Date("2022-10-15")
},
{
PersonId: "",
LicenseNumber : "P626-168-229-765",
LicenseType: "Learner",
ValidFromDate : new Date("2017-08-16"),
ValidToDate : new Date("2021-11-15")
},
{
PersonId: "",
LicenseNumber : "S152-780-97-415-0",
LicenseType: "Probationary",
ValidFromDate : new Date("2015-08-15"),
ValidToDate : new Date("2021-08-21")
}
];
export const PERSON = [
{
FirstName : "Raul",
LastName : "Lewis",
DOB : new Date("1963-08-19"),
Address : "1719 University Street, Seattle, WA, 98109",
GovId : "LEWISR261LL",
GovIdType : "Driver License"
},
{
FirstName : "Brent",
LastName : "Logan",
DOB : new Date("1967-07-03"),
Address : "43 Stockert Hollow Road, Everett, WA, 98203",
GovId : "LOGANB486CG",
GovIdType : "Driver License"
},
{
FirstName : "Alexis",
LastName : "Pena",
DOB : new Date("1974-02-10"),
Address : "4058 Melrose Street, Spokane Valley, WA, 99206",
GovId : "744 849 301",
GovIdType : "SSN"
},
{
FirstName : "Melvin",
LastName : "Parker",
DOB : new Date("1976-05-22"),
Address : "4362 Ryder Avenue, Seattle, WA, 98101",
GovId : "P626-168-229-765",
GovIdType : "Passport"
},
{
FirstName : "Salvatore",
LastName : "Spencer",
DOB : new Date("1997-11-15"),
Address : "4450 Honeysuckle Lane, Seattle, WA, 98101",
GovId : "S152-780-97-415-0",
GovIdType : "Passport"
}
];
export const VEHICLE = [
{
VIN : "1N4AL11D75C109151",
Type : "Sedan",
Year : 2011,
Make : "Audi",
Model : "A5",
Color : "Silver"
},
{
VIN : "KM8SRDHF6EU074761",
Type : "Sedan",
Year : 2015,
Make : "Tesla",
Model : "Model S",
Color : "Blue"
},
{
VIN : "3HGGK5G53FM761765",
Type : "Motorcycle",
Year : 2011,
Make : "Ducati",
Model : "Monster 1200",
Color : "Yellow"
},
{
VIN : "1HVBBAANXWH544237",
Type : "Semi",
Year : 2009,
Make : "Ford",
Model : "F 150",
Color : "Black"
},
{
VIN : "1C4RJFAG0FC625797",
Type : "Sedan",
Year : 2019,
Make : "Mercedes",
Model : "CLK 350",
Color : "White"
}
];
export const VEHICLE_REGISTRATION = [
{
VIN : "1N4AL11D75C109151",
LicensePlateNumber : "LEWISR261LL",
State : "WA",
City : "Seattle",
ValidFromDate : new Date("2017-08-21"),
ValidToDate : new Date("2020-05-11"),
PendingPenaltyTicketAmount : new Decimal(9025, -2),
Owners : {
PrimaryOwner : { PersonId : "" },
SecondaryOwners : EMPTY_SECONDARY_OWNERS
}
},
{
VIN : "KM8SRDHF6EU074761",
LicensePlateNumber : "CA762X",
State : "WA",
City : "Kent",
PendingPenaltyTicketAmount : new Decimal(13075, -2),
ValidFromDate : new Date("2017-09-14"),
ValidToDate : new Date("2020-06-25"),
Owners : {
PrimaryOwner : { PersonId : "" },
SecondaryOwners : EMPTY_SECONDARY_OWNERS
}
},
{
VIN : "3HGGK5G53FM761765",
LicensePlateNumber : "CD820Z",
State : "WA",
City : "Everett",
PendingPenaltyTicketAmount : new Decimal(44230, -2),
ValidFromDate : new Date("2011-03-17"),
ValidToDate : new Date("2021-03-24"),
Owners : {
PrimaryOwner : { PersonId : "" },
SecondaryOwners : EMPTY_SECONDARY_OWNERS
}
},
{
VIN : "1HVBBAANXWH544237",
LicensePlateNumber : "LS477D",
State : "WA",
City : "Tacoma",
PendingPenaltyTicketAmount : new Decimal(4220, -2),
ValidFromDate : new Date("2011-10-26"),
ValidToDate : new Date("2023-09-25"),
Owners : {
PrimaryOwner : { PersonId : "" },
SecondaryOwners : EMPTY_SECONDARY_OWNERS
}
},
{
VIN : "1C4RJFAG0FC625797",
LicensePlateNumber : "TH393F",
State : "WA",
City : "Olympia",
PendingPenaltyTicketAmount : new Decimal(3045, -2),
ValidFromDate : new Date("2013-09-02"),
ValidToDate : new Date("2024-03-19"),
Owners : {
PrimaryOwner : { PersonId : "" },
SecondaryOwners : EMPTY_SECONDARY_OWNERS
}
}
];
```
1. `Util.ts`— Un modulo di utilità che importa dal `ion-js` pacchetto per fornire funzioni di supporto che convertono, analizzano e stampano i dati di [Amazon Ion.](ion.md)
```
/*
* 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 { Result, TransactionExecutor } from "amazon-qldb-driver-nodejs";
import { GetBlockResponse, GetDigestResponse, ValueHolder } from "aws-sdk/clients/qldb";
import {
Decimal,
decodeUtf8,
dom,
IonTypes,
makePrettyWriter,
makeReader,
Reader,
Timestamp,
toBase64,
Writer
} from "ion-js";
import { error } from "./LogUtil";
/**
* TODO: Replace this with json.stringify
* Returns the string representation of a given BlockResponse.
* @param blockResponse The BlockResponse to convert to string.
* @returns The string representation of the supplied BlockResponse.
*/
export function blockResponseToString(blockResponse: GetBlockResponse): string {
let stringBuilder: string = "";
if (blockResponse.Block.IonText) {
stringBuilder = stringBuilder + "Block: " + blockResponse.Block.IonText + ", ";
}
if (blockResponse.Proof.IonText) {
stringBuilder = stringBuilder + "Proof: " + blockResponse.Proof.IonText;
}
stringBuilder = "{" + stringBuilder + "}";
const writer: Writer = makePrettyWriter();
const reader: Reader = makeReader(stringBuilder);
writer.writeValues(reader);
return decodeUtf8(writer.getBytes());
}
/**
* TODO: Replace this with json.stringify
* Returns the string representation of a given GetDigestResponse.
* @param digestResponse The GetDigestResponse to convert to string.
* @returns The string representation of the supplied GetDigestResponse.
*/
export function digestResponseToString(digestResponse: GetDigestResponse): string {
let stringBuilder: string = "";
if (digestResponse.Digest) {
stringBuilder += "Digest: " + JSON.stringify(toBase64( digestResponse.Digest)) + ", ";
}
if (digestResponse.DigestTipAddress.IonText) {
stringBuilder += "DigestTipAddress: " + digestResponse.DigestTipAddress.IonText;
}
stringBuilder = "{" + stringBuilder + "}";
const writer: Writer = makePrettyWriter();
const reader: Reader = makeReader(stringBuilder);
writer.writeValues(reader);
return decodeUtf8(writer.getBytes());
}
/**
* Get the document IDs from the given table.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param tableName The table name to query.
* @param field A field to query.
* @param value The key of the given field.
* @returns Promise which fulfills with the document ID as a string.
*/
export async function getDocumentId(
txn: TransactionExecutor,
tableName: string,
field: string,
value: string
): Promise {
const query: string = `SELECT id FROM ${tableName} AS t BY id WHERE t.${field} = ?`;
let documentId: string = undefined;
await txn.execute(query, value).then((result: Result) => {
const resultList: dom.Value[] = result.getResultList();
if (resultList.length === 0) {
throw new Error(`Unable to retrieve document ID using ${value}.`);
}
documentId = resultList[0].get("id").stringValue();
}).catch((err: any) => {
error(`Error getting documentId: ${err}`);
});
return documentId;
}
/**
* Sleep for the specified amount of time.
* @param ms The amount of time to sleep in milliseconds.
* @returns Promise which fulfills with void.
*/
export function sleep(ms: number): Promise {
return new Promise(resolve => setTimeout(resolve, ms));
}
/**
* Find the value of a given path in an Ion value. The path should contain a blob value.
* @param value The Ion value that contains the journal block attributes.
* @param path The path to a certain attribute.
* @returns Uint8Array value of the blob, or null if the attribute cannot be found in the Ion value
* or is not of type Blob
*/
export function getBlobValue(value: dom.Value, path: string): Uint8Array | null {
const attribute: dom.Value = value.get(path);
if (attribute !== null && attribute.getType() === IonTypes.BLOB) {
return attribute.uInt8ArrayValue();
}
return null;
}
/**
* TODO: Replace this with json.stringify
* Returns the string representation of a given ValueHolder.
* @param valueHolder The ValueHolder to convert to string.
* @returns The string representation of the supplied ValueHolder.
*/
export function valueHolderToString(valueHolder: ValueHolder): string {
const stringBuilder: string = `{ IonText: ${valueHolder.IonText}}`;
const writer: Writer = makePrettyWriter();
const reader: Reader = makeReader(stringBuilder);
writer.writeValues(reader);
return decodeUtf8(writer.getBytes());
}
/**
* Converts a given value to Ion using the provided writer.
* @param value The value to convert to Ion.
* @param ionWriter The Writer to pass the value into.
* @throws Error: If the given value cannot be converted to Ion.
*/
export function writeValueAsIon(value: any, ionWriter: Writer): void {
switch (typeof value) {
case "string":
ionWriter.writeString(value);
break;
case "boolean":
ionWriter.writeBoolean(value);
break;
case "number":
ionWriter.writeInt(value);
break;
case "object":
if (Array.isArray(value)) {
// Object is an array.
ionWriter.stepIn(IonTypes.LIST);
for (const element of value) {
writeValueAsIon(element, ionWriter);
}
ionWriter.stepOut();
} else if (value instanceof Date) {
// Object is a Date.
ionWriter.writeTimestamp(Timestamp.parse(value.toISOString()));
} else if (value instanceof Decimal) {
// Object is a Decimal.
ionWriter.writeDecimal(value);
} else if (value === null) {
ionWriter.writeNull(IonTypes.NULL);
} else {
// Object is a struct.
ionWriter.stepIn(IonTypes.STRUCT);
for (const key of Object.keys(value)) {
ionWriter.writeFieldName(key);
writeValueAsIon(value[key], ionWriter);
}
ionWriter.stepOut();
}
break;
default:
throw new Error(`Cannot convert to Ion for type: ${(typeof value)}.`);
}
}
```
**Nota**
La `getDocumentId` funzione esegue una query che restituisce un documento IDs assegnato dal sistema da una tabella. Per ulteriori informazioni, consulta [Utilizzo della clausola BY per interrogare l'ID del documento](working.metadata.by-clause.md).
1. Utilizzate il seguente programma (`InsertDocument.ts`) per inserire i dati di esempio nelle tabelle.
```
/*
* 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 { dom } from "ion-js";
import { getQldbDriver } from "./ConnectToLedger";
import { DRIVERS_LICENSE, PERSON, VEHICLE, VEHICLE_REGISTRATION } from "./model/SampleData";
import {
DRIVERS_LICENSE_TABLE_NAME,
PERSON_TABLE_NAME,
VEHICLE_REGISTRATION_TABLE_NAME,
VEHICLE_TABLE_NAME
} from "./qldb/Constants";
import { error, log } from "./qldb/LogUtil";
/**
* Insert the given list of documents into a table in a single transaction.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param tableName Name of the table to insert documents into.
* @param documents List of documents to insert.
* @returns Promise which fulfills with a {@linkcode Result} object.
*/
export async function insertDocument(
txn: TransactionExecutor,
tableName: string,
documents: object[]
): Promise {
const statement: string = `INSERT INTO ${tableName} ?`;
const result: Result = await txn.execute(statement, documents);
return result;
}
/**
* Handle the insertion of documents and updating PersonIds all in a single transaction.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @returns Promise which fulfills with void.
*/
async function updateAndInsertDocuments(txn: TransactionExecutor): Promise {
log("Inserting multiple documents into the 'Person' table...");
const documentIds: Result = await insertDocument(txn, PERSON_TABLE_NAME, PERSON);
const listOfDocumentIds: dom.Value[] = documentIds.getResultList();
log("Updating PersonIds for 'DriversLicense' and PrimaryOwner for 'VehicleRegistration'...");
updatePersonId(listOfDocumentIds);
log("Inserting multiple documents into the remaining tables...");
await Promise.all([
insertDocument(txn, DRIVERS_LICENSE_TABLE_NAME, DRIVERS_LICENSE),
insertDocument(txn, VEHICLE_REGISTRATION_TABLE_NAME, VEHICLE_REGISTRATION),
insertDocument(txn, VEHICLE_TABLE_NAME, VEHICLE)
]);
}
/**
* Update the PersonId value for DriversLicense records and the PrimaryOwner value for VehicleRegistration records.
* @param documentIds List of document IDs.
*/
export function updatePersonId(documentIds: dom.Value[]): void {
documentIds.forEach((value: dom.Value, i: number) => {
const documentId: string = value.get("documentId").stringValue();
DRIVERS_LICENSE[i].PersonId = documentId;
VEHICLE_REGISTRATION[i].Owners.PrimaryOwner.PersonId = documentId;
});
}
/**
* Insert documents into a table in a QLDB ledger.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbDriver: QldbDriver = getQldbDriver();
await qldbDriver.executeLambda(async (txn: TransactionExecutor) => {
await updateAndInsertDocuments(txn);
});
} catch (e) {
error(`Unable to insert documents: ${e}`);
}
}
if (require.main === module) {
main();
}
```
**Nota**
Questo programma dimostra come chiamare la `execute` funzione con valori parametrizzati. È possibile passare parametri di dati oltre all'istruzione PartiQL che si desidera eseguire. Utilizzate un punto interrogativo (`?`) come segnaposto variabile nella stringa dell'istruzione.
Se un'`INSERT`istruzione ha esito positivo, restituisce il valore `id` di ogni documento inserito.
1. Per eseguire il programma transpiled, immettete il seguente comando.
```
node dist/InsertDocument.js
```
Successivamente, è possibile utilizzare `SELECT` le istruzioni per leggere i dati dalle tabelle del registro. `vehicle-registration` Passa a [Passaggio 4: interrogare le tabelle in un libro mastro](getting-started.nodejs.step-4.md).
# Passaggio 4: interrogare le tabelle in un libro mastro
**Importante**
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).
Dopo aver creato tabelle in un registro Amazon QLDB e averle caricate con i dati, puoi eseguire query per rivedere i dati di immatricolazione dei veicoli che hai appena inserito. QLDB [utilizza](ql-reference.md) PartiQL come linguaggio di interrogazione [e Amazon](ion.md) Ion come modello di dati orientato ai documenti.
PartiQL è un linguaggio di query open source compatibile con SQL che è stato esteso per funzionare con Ion. Con PartiQL, puoi inserire, interrogare e gestire i tuoi dati con operatori SQL familiari. Amazon Ion è un superset di JSON. Ion è un formato di dati open source basato su documenti che offre la flessibilità di archiviazione ed elaborazione di dati strutturati, semistrutturati e annidati.
In questo passaggio, si utilizzano `SELECT` le istruzioni per leggere i dati dalle tabelle del registro. `vehicle-registration`
**avvertimento**
Quando si esegue una query in QLDB senza una ricerca indicizzata, viene richiamata una scansione completa della tabella. PartiQL supporta tali query perché è compatibile con SQL. Tuttavia, *non* eseguire scansioni di tabelle per casi d'uso di produzione in QLDB. Le scansioni delle tabelle possono causare problemi di prestazioni su tabelle di grandi dimensioni, inclusi conflitti di concorrenza e timeout delle transazioni.
Per evitare le scansioni delle tabelle, è necessario eseguire istruzioni con una clausola di `WHERE` predicato utilizzando un operatore di *uguaglianza* su un campo indicizzato o un ID di documento; ad esempio, o. `WHERE indexedField = 123` `WHERE indexedField IN (456, 789)` Per ulteriori informazioni, consulta [Ottimizzazione delle prestazioni delle query](working.optimize.md).
**Per interrogare le tabelle**
1. Usa il seguente programma (`FindVehicles.ts`) per interrogare tutti i veicoli registrati con una persona nel tuo registro.
```
/*
* 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 { dom } from "ion-js";
import { getQldbDriver } from "./ConnectToLedger";
import { PERSON } from "./model/SampleData";
import { PERSON_TABLE_NAME } from "./qldb/Constants";
import { error, log } from "./qldb/LogUtil";
import { getDocumentId } from "./qldb/Util";
import { prettyPrintResultList } from "./ScanTable";
/**
* Query 'Vehicle' and 'VehicleRegistration' tables using a unique document ID in one transaction.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param govId The owner's government ID.
* @returns Promise which fulfills with void.
*/
async function findVehiclesForOwner(txn: TransactionExecutor, govId: string): Promise {
const documentId: string = await getDocumentId(txn, PERSON_TABLE_NAME, "GovId", govId);
const query: string = "SELECT Vehicle FROM Vehicle INNER JOIN VehicleRegistration AS r " +
"ON Vehicle.VIN = r.VIN WHERE r.Owners.PrimaryOwner.PersonId = ?";
await txn.execute(query, documentId).then((result: Result) => {
const resultList: dom.Value[] = result.getResultList();
log(`List of vehicles for owner with GovId: ${govId}`);
prettyPrintResultList(resultList);
});
}
/**
* Find all vehicles registered under a person.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbDriver: QldbDriver = getQldbDriver();
await qldbDriver.executeLambda(async (txn: TransactionExecutor) => {
await findVehiclesForOwner(txn, PERSON[0].GovId);
});
} catch (e) {
error(`Error getting vehicles for owner: ${e}`);
}
}
if (require.main === module) {
main();
}
```
**Nota**
Innanzitutto, questo programma interroga la `Person` tabella del documento per ottenere il relativo `GovId LEWISR261LL` campo di `id` metadati.
Quindi, utilizza questo documento `id` come chiave esterna per interrogare la `VehicleRegistration` tabella. `PrimaryOwner.PersonId` Inoltre si unisce `VehicleRegistration` alla `Vehicle` tabella sul `VIN` campo.
1. Per eseguire il programma transpiled, inserisci il seguente comando.
```
node dist/FindVehicles.js
```
Per ulteriori informazioni sulla modifica dei documenti nelle tabelle del `vehicle-registration` libro mastro, vedere. [Fase 5: Modificare i documenti in un libro mastro](getting-started.nodejs.step-5.md)
# Fase 5: Modificare i documenti in un libro mastro
**Importante**
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).
Ora che hai dei dati su cui lavorare, puoi iniziare a modificare i documenti nel `vehicle-registration` registro di Amazon QLDB. In questa fase, i seguenti esempi di codice mostrano come eseguire istruzioni DML (Data Manipulation Language). Queste istruzioni aggiornano il proprietario principale di un veicolo e aggiungono un proprietario secondario a un altro veicolo.
**Per modificare i documenti**
1. Utilizzate il seguente programma (`TransferVehicleOwnership.ts`) per aggiornare il proprietario principale del veicolo inserendo il `1N4AL11D75C109151` VIN nel registro.
```
/*
* 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 { dom } from "ion-js";
import { getQldbDriver } from "./ConnectToLedger";
import { PERSON, VEHICLE } from "./model/SampleData";
import { PERSON_TABLE_NAME } from "./qldb/Constants";
import { error, log } from "./qldb/LogUtil";
import { getDocumentId } from "./qldb/Util";
/**
* Query a driver's information using the given ID.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param documentId The unique ID of a document in the Person table.
* @returns Promise which fulfills with an Ion value containing the person.
*/
export async function findPersonFromDocumentId(txn: TransactionExecutor, documentId: string): Promise {
const query: string = "SELECT p.* FROM Person AS p BY pid WHERE pid = ?";
let personId: dom.Value;
await txn.execute(query, documentId).then((result: Result) => {
const resultList: dom.Value[] = result.getResultList();
if (resultList.length === 0) {
throw new Error(`Unable to find person with ID: ${documentId}.`);
}
personId = resultList[0];
});
return personId;
}
/**
* Find the primary owner for the given VIN.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param vin The VIN to find primary owner for.
* @returns Promise which fulfills with an Ion value containing the primary owner.
*/
export async function findPrimaryOwnerForVehicle(txn: TransactionExecutor, vin: string): Promise {
log(`Finding primary owner for vehicle with VIN: ${vin}`);
const query: string = "SELECT Owners.PrimaryOwner.PersonId FROM VehicleRegistration AS v WHERE v.VIN = ?";
let documentId: string = undefined;
await txn.execute(query, vin).then((result: Result) => {
const resultList: dom.Value[] = result.getResultList();
if (resultList.length === 0) {
throw new Error(`Unable to retrieve document ID using ${vin}.`);
}
const PersonIdValue: dom.Value = resultList[0].get("PersonId");
if (PersonIdValue === null) {
throw new Error(`Expected field name PersonId not found.`);
}
documentId = PersonIdValue.stringValue();
});
return findPersonFromDocumentId(txn, documentId);
}
/**
* Update the primary owner for a vehicle using the given VIN.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param vin The VIN for the vehicle to operate on.
* @param documentId New PersonId for the primary owner.
* @returns Promise which fulfills with void.
*/
async function updateVehicleRegistration(txn: TransactionExecutor, vin: string, documentId: string): Promise {
const statement: string = "UPDATE VehicleRegistration AS r SET r.Owners.PrimaryOwner.PersonId = ? WHERE r.VIN = ?";
log(`Updating the primary owner for vehicle with VIN: ${vin}...`);
await txn.execute(statement, documentId, vin).then((result: Result) => {
const resultList: dom.Value[] = result.getResultList();
if (resultList.length === 0) {
throw new Error("Unable to transfer vehicle, could not find registration.");
}
log(`Successfully transferred vehicle with VIN ${vin} to new owner.`);
});
}
/**
* Validate the current owner of the given vehicle and transfer its ownership to a new owner in a single transaction.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param vin The VIN of the vehicle to transfer ownership of.
* @param currentOwner The GovId of the current owner of the vehicle.
* @param newOwner The GovId of the new owner of the vehicle.
*/
export async function validateAndUpdateRegistration(
txn: TransactionExecutor,
vin: string,
currentOwner: string,
newOwner: string
): Promise {
const primaryOwner: dom.Value = await findPrimaryOwnerForVehicle(txn, vin);
const govIdValue: dom.Value = primaryOwner.get("GovId");
if (govIdValue !== null && govIdValue.stringValue() !== currentOwner) {
log("Incorrect primary owner identified for vehicle, unable to transfer.");
}
else {
const documentId: string = await getDocumentId(txn, PERSON_TABLE_NAME, "GovId", newOwner);
await updateVehicleRegistration(txn, vin, documentId);
log("Successfully transferred vehicle ownership!");
}
}
/**
* Find primary owner for a particular vehicle's VIN.
* Transfer to another primary owner for a particular vehicle's VIN.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbDriver: QldbDriver = getQldbDriver();
const vin: string = VEHICLE[0].VIN;
const previousOwnerGovId: string = PERSON[0].GovId;
const newPrimaryOwnerGovId: string = PERSON[1].GovId;
await qldbDriver.executeLambda(async (txn: TransactionExecutor) => {
await validateAndUpdateRegistration(txn, vin, previousOwnerGovId, newPrimaryOwnerGovId);
});
} catch (e) {
error(`Unable to connect and run queries: ${e}`);
}
}
if (require.main === module) {
main();
}
```
1. Per eseguire il programma transpiled, immettete il seguente comando.
```
node dist/TransferVehicleOwnership.js
```
1. Utilizzate il seguente programma (`AddSecondaryOwner.ts`) per aggiungere un proprietario secondario al veicolo con VIN `KM8SRDHF6EU074761` nel registro.
```
/*
* 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 { dom } from "ion-js";
import { getQldbDriver } from "./ConnectToLedger";
import { PERSON, VEHICLE_REGISTRATION } from "./model/SampleData";
import { PERSON_TABLE_NAME } from "./qldb/Constants";
import { error, log } from "./qldb/LogUtil";
import { getDocumentId } from "./qldb/Util";
import { prettyPrintResultList } from "./ScanTable";
/**
* Add a secondary owner into 'VehicleRegistration' table for a particular VIN.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param vin VIN of the vehicle to query.
* @param secondaryOwnerId The secondary owner's person ID.
* @returns Promise which fulfills with void.
*/
export async function addSecondaryOwner(
txn: TransactionExecutor,
vin: string,
secondaryOwnerId: string
): Promise {
log(`Inserting secondary owner for vehicle with VIN: ${vin}`);
const query: string =
`FROM VehicleRegistration AS v WHERE v.VIN = ? INSERT INTO v.Owners.SecondaryOwners VALUE ?`;
const personToInsert = {PersonId: secondaryOwnerId};
await txn.execute(query, vin, personToInsert).then(async (result: Result) => {
const resultList: dom.Value[] = result.getResultList();
log("VehicleRegistration Document IDs which had secondary owners added: ");
prettyPrintResultList(resultList);
});
}
/**
* Query for a document ID with a government ID.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param governmentId The government ID to query with.
* @returns Promise which fulfills with the document ID as a string.
*/
export async function getDocumentIdByGovId(txn: TransactionExecutor, governmentId: string): Promise {
const documentId: string = await getDocumentId(txn, PERSON_TABLE_NAME, "GovId", governmentId);
return documentId;
}
/**
* Check whether a driver has already been registered for the given VIN.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param vin VIN of the vehicle to query.
* @param secondaryOwnerId The secondary owner's person ID.
* @returns Promise which fulfills with a boolean.
*/
export async function isSecondaryOwnerForVehicle(
txn: TransactionExecutor,
vin: string,
secondaryOwnerId: string
): Promise {
log(`Finding secondary owners for vehicle with VIN: ${vin}`);
const query: string = "SELECT Owners.SecondaryOwners FROM VehicleRegistration AS v WHERE v.VIN = ?";
let doesExist: boolean = false;
await txn.execute(query, vin).then((result: Result) => {
const resultList: dom.Value[] = result.getResultList();
resultList.forEach((value: dom.Value) => {
const secondaryOwnersList: dom.Value[] = value.get("SecondaryOwners").elements();
secondaryOwnersList.forEach((secondaryOwner) => {
const personId: dom.Value = secondaryOwner.get("PersonId");
if (personId !== null && personId.stringValue() === secondaryOwnerId) {
doesExist = true;
}
});
});
});
return doesExist;
}
/**
* Finds and adds secondary owners for a vehicle.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbDriver: QldbDriver = getQldbDriver();
const vin: string = VEHICLE_REGISTRATION[1].VIN;
const govId: string = PERSON[0].GovId;
await qldbDriver.executeLambda(async (txn: TransactionExecutor) => {
const documentId: string = await getDocumentIdByGovId(txn, govId);
if (await isSecondaryOwnerForVehicle(txn, vin, documentId)) {
log(`Person with ID ${documentId} has already been added as a secondary owner of this vehicle.`);
} else {
await addSecondaryOwner(txn, vin, documentId);
}
});
log("Secondary owners successfully updated.");
} catch (e) {
error(`Unable to add secondary owner: ${e}`);
}
}
if (require.main === module) {
main();
}
```
1. Per eseguire il programma transpiled, immettete il seguente comando.
```
node dist/AddSecondaryOwner.js
```
Per esaminare queste modifiche nel `vehicle-registration` registro, vedere. [Fase 6: Visualizzare la cronologia delle revisioni di un documento](getting-started.nodejs.step-6.md)
# Fase 6: Visualizzare la cronologia delle revisioni di un documento
**Importante**
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).
Dopo aver modificato i dati di immatricolazione di un veicolo nel [passaggio precedente](getting-started.nodejs.step-5.md), puoi interrogare la cronologia di tutti i proprietari registrati e qualsiasi altro campo aggiornato. In questo passaggio, esegui una query sulla cronologia delle revisioni di un documento nella `VehicleRegistration` tabella del registro. `vehicle-registration`
**Per visualizzare la cronologia delle revisioni**
1. Utilizzate il seguente programma (`QueryHistory.ts`) per interrogare la cronologia delle revisioni del `VehicleRegistration` documento con VIN. `1N4AL11D75C109151`
```
/*
* 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 { dom } from "ion-js";
import { getQldbDriver } from "./ConnectToLedger";
import { VEHICLE_REGISTRATION } from "./model/SampleData";
import { VEHICLE_REGISTRATION_TABLE_NAME } from "./qldb/Constants";
import { prettyPrintResultList } from "./ScanTable";
import { error, log } from "./qldb/LogUtil";
import { getDocumentId } from "./qldb/Util";
/**
* Find previous primary owners for the given VIN in a single transaction.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param vin The VIN to find previous primary owners for.
* @returns Promise which fulfills with void.
*/
async function previousPrimaryOwners(txn: TransactionExecutor, vin: string): Promise {
const documentId: string = await getDocumentId(txn, VEHICLE_REGISTRATION_TABLE_NAME, "VIN", vin);
const todaysDate: Date = new Date();
// set todaysDate back one minute to ensure end time is in the past
// by the time the request reaches our backend
todaysDate.setMinutes(todaysDate.getMinutes() - 1);
const threeMonthsAgo: Date = new Date(todaysDate);
threeMonthsAgo.setMonth(todaysDate.getMonth() - 3);
const query: string =
`SELECT data.Owners.PrimaryOwner, metadata.version FROM history ` +
`(${VEHICLE_REGISTRATION_TABLE_NAME}, \`${threeMonthsAgo.toISOString()}\`, \`${todaysDate.toISOString()}\`) ` +
`AS h WHERE h.metadata.id = ?`;
await txn.execute(query, documentId).then((result: Result) => {
log(`Querying the 'VehicleRegistration' table's history using VIN: ${vin}.`);
const resultList: dom.Value[] = result.getResultList();
prettyPrintResultList(resultList);
});
}
/**
* Query a table's history for a particular set of documents.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbDriver: QldbDriver = getQldbDriver();
const vin: string = VEHICLE_REGISTRATION[0].VIN;
await qldbDriver.executeLambda(async (txn: TransactionExecutor) => {
await previousPrimaryOwners(txn, vin);
});
} catch (e) {
error(`Unable to query history to find previous owners: ${e}`);
}
}
if (require.main === module) {
main();
}
```
**Nota**
È possibile visualizzare la cronologia delle revisioni di un documento interrogando la sintassi incorporata [Funzione di cronologia](working.history.md#working.history.function) nella seguente sintassi.
```
SELECT * FROM history( table_name [, `start-time` [, `end-time` ] ] ) AS h
[ WHERE h.metadata.id = 'id' ]
```
L'*ora di inizio* e l'ora di *fine* sono entrambe opzionali. Sono valori letterali di Amazon Ion che possono essere indicati con backticks (). ``...`` Per ulteriori informazioni, consulta [Interrogazione di Ion con PartiQL in Amazon QLDB](ql-reference.query.md).
Come best practice, qualifica una query cronologica con un intervallo di date (ora di *inizio e ora di fine) e un* *ID del documento ()*. `metadata.id` [QLDB `SELECT` elabora le query nelle transazioni, che sono soggette a un limite di timeout delle transazioni.](limits.md#limits.fixed)
La cronologia QLDB è indicizzata in base all'ID del documento e al momento non è possibile creare indici di cronologia aggiuntivi. Le interrogazioni cronologiche che includono l'ora di inizio e l'ora di fine ottengono il vantaggio della qualificazione per intervalli di date.
1. Per eseguire il programma transpiled, immettete il seguente comando.
```
node dist/QueryHistory.js
```
Per verificare crittograficamente una revisione del documento nel registro, procedi a. `vehicle-registration` [Fase 7: Verificare un documento in un libro mastro](getting-started.nodejs.step-7.md)
# Fase 7: Verificare un documento in un libro mastro
**Importante**
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).
Con Amazon QLDB, puoi verificare in modo efficiente l'integrità di un documento nel diario del tuo libro mastro utilizzando l'hashing crittografico con SHA-256. Per ulteriori informazioni su come funzionano la verifica e l'hashing crittografico in QLDB, consulta. [Verifica dei dati in Amazon QLDB](verification.md)
In questo passaggio, verifichi una revisione del documento nella tabella del `VehicleRegistration` registro. `vehicle-registration` Innanzitutto, richiedi un digest, che viene restituito come file di output e funge da firma dell'intera cronologia delle modifiche del registro. Quindi, richiedi una bozza della revisione relativa a quel digest. Utilizzando questa prova, l'integrità della revisione viene verificata se tutti i controlli di convalida vengono superati.
**Per verificare la revisione di un documento**
1. Esamina i seguenti `.ts` file, che contengono gli oggetti QLDB necessari per la verifica.
1. `BlockAddress.ts`
```
/*
* 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 { ValueHolder } from "aws-sdk/clients/qldb";
import { dom, IonTypes } from "ion-js";
export class BlockAddress {
_strandId: string;
_sequenceNo: number;
constructor(strandId: string, sequenceNo: number) {
this._strandId = strandId;
this._sequenceNo = sequenceNo;
}
}
/**
* Convert a block address from an Ion value into a ValueHolder.
* Shape of the ValueHolder must be: {'IonText': "{strandId: <"strandId">, sequenceNo: }"}
* @param value The Ion value that contains the block address values to convert.
* @returns The ValueHolder that contains the strandId and sequenceNo.
*/
export function blockAddressToValueHolder(value: dom.Value): ValueHolder {
const blockAddressValue : dom.Value = getBlockAddressValue(value);
const strandId: string = getStrandId(blockAddressValue);
const sequenceNo: number = getSequenceNo(blockAddressValue);
const valueHolder: string = `{strandId: "${strandId}", sequenceNo: ${sequenceNo}}`;
const blockAddress: ValueHolder = {IonText: valueHolder};
return blockAddress;
}
/**
* Helper method that to get the Metadata ID.
* @param value The Ion value.
* @returns The Metadata ID.
*/
export function getMetadataId(value: dom.Value): string {
const metaDataId: dom.Value = value.get("id");
if (metaDataId === null) {
throw new Error(`Expected field name id, but not found.`);
}
return metaDataId.stringValue();
}
/**
* Helper method to get the Sequence No.
* @param value The Ion value.
* @returns The Sequence No.
*/
export function getSequenceNo(value : dom.Value): number {
const sequenceNo: dom.Value = value.get("sequenceNo");
if (sequenceNo === null) {
throw new Error(`Expected field name sequenceNo, but not found.`);
}
return sequenceNo.numberValue();
}
/**
* Helper method to get the Strand ID.
* @param value The Ion value.
* @returns The Strand ID.
*/
export function getStrandId(value: dom.Value): string {
const strandId: dom.Value = value.get("strandId");
if (strandId === null) {
throw new Error(`Expected field name strandId, but not found.`);
}
return strandId.stringValue();
}
export function getBlockAddressValue(value: dom.Value) : dom.Value {
const type = value.getType();
if (type !== IonTypes.STRUCT) {
throw new Error(`Unexpected format: expected struct, but got IonType: ${type.name}`);
}
const blockAddress: dom.Value = value.get("blockAddress");
if (blockAddress == null) {
throw new Error(`Expected field name blockAddress, but not found.`);
}
return blockAddress;
}
```
1. `Verifier.ts`
```
/*
* 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 { Digest, ValueHolder } from "aws-sdk/clients/qldb";
import { createHash } from "crypto";
import { dom, toBase64 } from "ion-js";
import { getBlobValue } from "./Util";
const HASH_LENGTH: number = 32;
const UPPER_BOUND: number = 8;
/**
* Build the candidate digest representing the entire ledger from the Proof hashes.
* @param proof The Proof object.
* @param leafHash The revision hash to pair with the first hash in the Proof hashes list.
* @returns The calculated root hash.
*/
function buildCandidateDigest(proof: ValueHolder, leafHash: Uint8Array): Uint8Array {
const parsedProof: Uint8Array[] = parseProof(proof);
const rootHash: Uint8Array = calculateRootHashFromInternalHash(parsedProof, leafHash);
return rootHash;
}
/**
* Combine the internal hashes and the leaf hash until only one root hash remains.
* @param internalHashes An array of hash values.
* @param leafHash The revision hash to pair with the first hash in the Proof hashes list.
* @returns The root hash constructed by combining internal hashes.
*/
function calculateRootHashFromInternalHash(internalHashes: Uint8Array[], leafHash: Uint8Array): Uint8Array {
const rootHash: Uint8Array = internalHashes.reduce(joinHashesPairwise, leafHash);
return rootHash;
}
/**
* Compare two hash values by converting each Uint8Array byte, which is unsigned by default,
* into a signed byte, assuming they are little endian.
* @param hash1 The hash value to compare.
* @param hash2 The hash value to compare.
* @returns Zero if the hash values are equal, otherwise return the difference of the first pair of non-matching bytes.
*/
function compareHashValues(hash1: Uint8Array, hash2: Uint8Array): number {
if (hash1.length !== HASH_LENGTH || hash2.length !== HASH_LENGTH) {
throw new Error("Invalid hash.");
}
for (let i = hash1.length-1; i >= 0; i--) {
const difference: number = (hash1[i]<<24 >>24) - (hash2[i]<<24 >>24);
if (difference !== 0) {
return difference;
}
}
return 0;
}
/**
* Helper method that concatenates two Uint8Array.
* @param arrays List of array to concatenate, in the order provided.
* @returns The concatenated array.
*/
function concatenate(...arrays: Uint8Array[]): Uint8Array {
let totalLength = 0;
for (const arr of arrays) {
totalLength += arr.length;
}
const result = new Uint8Array(totalLength);
let offset = 0;
for (const arr of arrays) {
result.set(arr, offset);
offset += arr.length;
}
return result;
}
/**
* Flip a single random bit in the given hash value.
* This method is intended to be used for purpose of demonstrating the QLDB verification features only.
* @param original The hash value to alter.
* @returns The altered hash with a single random bit changed.
*/
export function flipRandomBit(original: any): Uint8Array {
if (original.length === 0) {
throw new Error("Array cannot be empty!");
}
const bytePos: number = Math.floor(Math.random() * original.length);
const bitShift: number = Math.floor(Math.random() * UPPER_BOUND);
const alteredHash: Uint8Array = original;
alteredHash[bytePos] = alteredHash[bytePos] ^ (1 << bitShift);
return alteredHash;
}
/**
* Take two hash values, sort them, concatenate them, and generate a new hash value from the concatenated values.
* @param h1 Byte array containing one of the hashes to compare.
* @param h2 Byte array containing one of the hashes to compare.
* @returns The concatenated array of hashes.
*/
export function joinHashesPairwise(h1: Uint8Array, h2: Uint8Array): Uint8Array {
if (h1.length === 0) {
return h2;
}
if (h2.length === 0) {
return h1;
}
let concat: Uint8Array;
if (compareHashValues(h1, h2) < 0) {
concat = concatenate(h1, h2);
} else {
concat = concatenate(h2, h1);
}
const hash = createHash('sha256');
hash.update(concat);
const newDigest: Uint8Array = hash.digest();
return newDigest;
}
/**
* Parse the Block object returned by QLDB and retrieve block hash.
* @param valueHolder A structure containing an Ion string value.
* @returns The block hash.
*/
export function parseBlock(valueHolder: ValueHolder): Uint8Array {
const block: dom.Value = dom.load(valueHolder.IonText);
const blockHash: Uint8Array = getBlobValue(block, "blockHash");
return blockHash;
}
/**
* Parse the Proof object returned by QLDB into an iterator.
* The Proof object returned by QLDB is a dictionary like the following:
* {'IonText': '[{{}},{{}}]'}
* @param valueHolder A structure containing an Ion string value.
* @returns A list of hash values.
*/
function parseProof(valueHolder: ValueHolder): Uint8Array[] {
const proofs : dom.Value = dom.load(valueHolder.IonText);
return proofs.elements().map(proof => proof.uInt8ArrayValue());
}
/**
* Verify document revision against the provided digest.
* @param documentHash The SHA-256 value representing the document revision to be verified.
* @param digest The SHA-256 hash value representing the ledger digest.
* @param proof The Proof object retrieved from GetRevision.getRevision.
* @returns If the document revision verifies against the ledger digest.
*/
export function verifyDocument(documentHash: Uint8Array, digest: Digest, proof: ValueHolder): boolean {
const candidateDigest = buildCandidateDigest(proof, documentHash);
return (toBase64( digest) === toBase64(candidateDigest));
}
```
1. Utilizzate due `.ts` programmi (`GetDigest.ts`e`GetRevision.ts`) per eseguire le seguenti operazioni:
+ Richiedete un nuovo digest dal `vehicle-registration` registro.
+ Richiedi una bozza per ogni revisione del documento con VIN `1N4AL11D75C109151` dalla tabella. `VehicleRegistration`
+ Verifica le revisioni utilizzando il digest restituito e verifica ricalcolando il digest.
Il `GetDigest.ts` programma contiene il codice seguente.
```
/*
* 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 { QLDB } from "aws-sdk";
import { GetDigestRequest, GetDigestResponse } from "aws-sdk/clients/qldb";
import { LEDGER_NAME } from "./qldb/Constants";
import { error, log } from "./qldb/LogUtil";
import { digestResponseToString } from "./qldb/Util";
/**
* Get the digest of a ledger's journal.
* @param ledgerName Name of the ledger to operate on.
* @param qldbClient The QLDB control plane client to use.
* @returns Promise which fulfills with a GetDigestResponse.
*/
export async function getDigestResult(ledgerName: string, qldbClient: QLDB): Promise {
const request: GetDigestRequest = {
Name: ledgerName
};
const result: GetDigestResponse = await qldbClient.getDigest(request).promise();
return result;
}
/**
* This is an example for retrieving the digest of a particular ledger.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbClient: QLDB = new QLDB();
log(`Retrieving the current digest for ledger: ${LEDGER_NAME}.`);
const digest: GetDigestResponse = await getDigestResult(LEDGER_NAME, qldbClient);
log(`Success. Ledger digest: \n${digestResponseToString(digest)}.`);
} catch (e) {
error(`Unable to get a ledger digest: ${e}`);
}
}
if (require.main === module) {
main();
}
```
**Nota**
Usa la `getDigest` funzione per richiedere un riassunto che copra la *punta* corrente del diario nel tuo libro mastro. Il tip of the journal si riferisce all'ultimo blocco eseguito nel momento in cui QLDB riceve la tua richiesta.
Il `GetRevision.ts` programma contiene il seguente codice.
```
/*
* 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, TransactionExecutor } from "amazon-qldb-driver-nodejs";
import { QLDB } from "aws-sdk";
import { Digest, GetDigestResponse, GetRevisionRequest, GetRevisionResponse, ValueHolder } from "aws-sdk/clients/qldb";
import { dom, toBase64 } from "ion-js";
import { getQldbDriver } from "./ConnectToLedger";
import { getDigestResult } from './GetDigest';
import { VEHICLE_REGISTRATION } from "./model/SampleData"
import { blockAddressToValueHolder, getMetadataId } from './qldb/BlockAddress';
import { LEDGER_NAME } from './qldb/Constants';
import { error, log } from "./qldb/LogUtil";
import { getBlobValue, valueHolderToString } from "./qldb/Util";
import { flipRandomBit, verifyDocument } from "./qldb/Verifier";
/**
* Get the revision data object for a specified document ID and block address.
* Also returns a proof of the specified revision for verification.
* @param ledgerName Name of the ledger containing the document to query.
* @param documentId Unique ID for the document to be verified, contained in the committed view of the document.
* @param blockAddress The location of the block to request.
* @param digestTipAddress The latest block location covered by the digest.
* @param qldbClient The QLDB control plane client to use.
* @returns Promise which fulfills with a GetRevisionResponse.
*/
async function getRevision(
ledgerName: string,
documentId: string,
blockAddress: ValueHolder,
digestTipAddress: ValueHolder,
qldbClient: QLDB
): Promise {
const request: GetRevisionRequest = {
Name: ledgerName,
BlockAddress: blockAddress,
DocumentId: documentId,
DigestTipAddress: digestTipAddress
};
const result: GetRevisionResponse = await qldbClient.getRevision(request).promise();
return result;
}
/**
* Query the table metadata for a particular vehicle for verification.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param vin VIN to query the table metadata of a specific registration with.
* @returns Promise which fulfills with a list of Ion values that contains the results of the query.
*/
export async function lookupRegistrationForVin(txn: TransactionExecutor, vin: string): Promise {
log(`Querying the 'VehicleRegistration' table for VIN: ${vin}...`);
let resultList: dom.Value[];
const query: string = "SELECT blockAddress, metadata.id FROM _ql_committed_VehicleRegistration WHERE data.VIN = ?";
await txn.execute(query, vin).then(function(result) {
resultList = result.getResultList();
});
return resultList;
}
/**
* Verify each version of the registration for the given VIN.
* @param txn The {@linkcode TransactionExecutor} for lambda execute.
* @param ledgerName The ledger to get the digest from.
* @param vin VIN to query the revision history of a specific registration with.
* @param qldbClient The QLDB control plane client to use.
* @returns Promise which fulfills with void.
* @throws Error: When verification fails.
*/
export async function verifyRegistration(
txn: TransactionExecutor,
ledgerName: string,
vin: string,
qldbClient: QLDB
): Promise {
log(`Let's verify the registration with VIN = ${vin}, in ledger = ${ledgerName}.`);
const digest: GetDigestResponse = await getDigestResult(ledgerName, qldbClient);
const digestBytes: Digest = digest.Digest;
const digestTipAddress: ValueHolder = digest.DigestTipAddress;
log(
`Got a ledger digest: digest tip address = \n${valueHolderToString(digestTipAddress)},
digest = \n${toBase64( digestBytes)}.`
);
log(`Querying the registration with VIN = ${vin} to verify each version of the registration...`);
const resultList: dom.Value[] = await lookupRegistrationForVin(txn, vin);
log("Getting a proof for the document.");
for (const result of resultList) {
const blockAddress: ValueHolder = blockAddressToValueHolder(result);
const documentId: string = getMetadataId(result);
const revisionResponse: GetRevisionResponse = await getRevision(
ledgerName,
documentId,
blockAddress,
digestTipAddress,
qldbClient
);
const revision: dom.Value = dom.load(revisionResponse.Revision.IonText);
const documentHash: Uint8Array = getBlobValue(revision, "hash");
const proof: ValueHolder = revisionResponse.Proof;
log(`Got back a proof: ${valueHolderToString(proof)}.`);
let verified: boolean = verifyDocument(documentHash, digestBytes, proof);
if (!verified) {
throw new Error("Document revision is not verified.");
} else {
log("Success! The document is verified.");
}
const alteredDocumentHash: Uint8Array = flipRandomBit(documentHash);
log(
`Flipping one bit in the document's hash and assert that the document is NOT verified.
The altered document hash is: ${toBase64(alteredDocumentHash)}`
);
verified = verifyDocument(alteredDocumentHash, digestBytes, proof);
if (verified) {
throw new Error("Expected altered document hash to not be verified against digest.");
} else {
log("Success! As expected flipping a bit in the document hash causes verification to fail.");
}
log(`Finished verifying the registration with VIN = ${vin} in ledger = ${ledgerName}.`);
}
}
/**
* Verify the integrity of a document revision in a QLDB ledger.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbClient: QLDB = new QLDB();
const qldbDriver: QldbDriver = getQldbDriver();
const registration = VEHICLE_REGISTRATION[0];
const vin: string = registration.VIN;
await qldbDriver.executeLambda(async (txn: TransactionExecutor) => {
await verifyRegistration(txn, LEDGER_NAME, vin, qldbClient);
});
} catch (e) {
error(`Unable to verify revision: ${e}`);
}
}
if (require.main === module) {
main();
}
```
**Nota**
Dopo che la `getRevision` funzione ha restituito una bozza per la revisione del documento specificata, questo programma utilizza un'API lato client per verificare tale revisione.
1. Per eseguire il programma transpiled, immettete il seguente comando.
```
node dist/GetRevision.js
```
Se non hai più bisogno di usare il `vehicle-registration` libro mastro, procedi a. [Passaggio 8 (opzionale): Pulisci le risorse](getting-started.nodejs.step-8.md)
# Passaggio 8 (opzionale): Pulisci le risorse
**Importante**
Avviso di fine del supporto: i clienti esistenti potranno utilizzare Amazon QLDB fino alla fine del supporto, il 31/07/2025. Per ulteriori dettagli, consulta [Migrare un registro Amazon QLDB su Amazon Aurora PostgreSQL](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/).
Puoi `vehicle-registration` continuare a utilizzare il registro. Tuttavia, se non è più necessario, è necessario eliminarlo.
**Per eliminare il libro mastro**
1. Utilizzate il seguente programma (`DeleteLedger.ts`) per eliminare il `vehicle-registration` registro e tutto il suo contenuto.
```
/*
* 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 { isResourceNotFoundException } from "amazon-qldb-driver-nodejs";
import { AWSError, QLDB } from "aws-sdk";
import { DeleteLedgerRequest, DescribeLedgerRequest } from "aws-sdk/clients/qldb";
import { setDeletionProtection } from "./DeletionProtection";
import { LEDGER_NAME } from "./qldb/Constants";
import { error, log } from "./qldb/LogUtil";
import { sleep } from "./qldb/Util";
const LEDGER_DELETION_POLL_PERIOD_MS = 20000;
/**
* Send a request to QLDB to delete the specified ledger.
* @param ledgerName Name of the ledger to be deleted.
* @param qldbClient The QLDB control plane client to use.
* @returns Promise which fulfills with void.
*/
export async function deleteLedger(ledgerName: string, qldbClient: QLDB): Promise {
log(`Attempting to delete the ledger with name: ${ledgerName}`);
const request: DeleteLedgerRequest = {
Name: ledgerName
};
await qldbClient.deleteLedger(request).promise();
log("Success.");
}
/**
* Wait for the ledger to be deleted.
* @param ledgerName Name of the ledger to be deleted.
* @param qldbClient The QLDB control plane client to use.
* @returns Promise which fulfills with void.
*/
export async function waitForDeleted(ledgerName: string, qldbClient: QLDB): Promise {
log("Waiting for the ledger to be deleted...");
const request: DescribeLedgerRequest = {
Name: ledgerName
};
let isDeleted: boolean = false;
while (true) {
await qldbClient.describeLedger(request).promise().catch((error: AWSError) => {
if (isResourceNotFoundException(error)) {
isDeleted = true;
log("Success. Ledger is deleted.");
}
});
if (isDeleted) {
break;
}
log("The ledger is still being deleted. Please wait...");
await sleep(LEDGER_DELETION_POLL_PERIOD_MS);
}
}
/**
* Delete a ledger.
* @returns Promise which fulfills with void.
*/
const main = async function(): Promise {
try {
const qldbClient: QLDB = new QLDB();
await setDeletionProtection(LEDGER_NAME, qldbClient, false);
await deleteLedger(LEDGER_NAME, qldbClient);
await waitForDeleted(LEDGER_NAME, qldbClient);
} catch (e) {
error(`Unable to delete the ledger: ${e}`);
}
}
if (require.main === module) {
main();
}
```
**Nota**
Se la protezione da eliminazione è abilitata per il registro, devi prima disabilitarla prima di poter eliminare il registro utilizzando l'API QLDB.
1. Per eseguire il programma transpiled, inserisci il seguente comando.
```
node dist/DeleteLedger.js
```