Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Anleitung zu Amazon QLDB Node.js
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
In dieser Implementierung der Tutorial-Beispielanwendung verwenden Sie den Amazon QLDB-Treiber mit dem AWS SDK für JavaScript in Node.js, um ein QLDB-Ledger zu erstellen und es mit Beispieldaten zu füllen.
Während Sie dieses Tutorial durcharbeiten, können Sie sich auf die API-Referenz für [AWS SDK für JavaScript Verwaltungs-API-Operationen](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/) beziehen. Informationen zu Transaktionsdatenoperationen finden Sie in der API-Referenz zum [QLDB-Treiber für Node.js](https://amazon-qldb-docs.s3.amazonaws.com/drivers/nodejs/3.1.0/index.html).
**Anmerkung**
Gegebenenfalls enthalten einige Tutorialschritte unterschiedliche Befehle oder Codebeispiele für jede unterstützte Hauptversion des QLDB-Treibers für Node.js.
**Topics**
+ [
# Installation der Amazon QLDB-Beispielanwendung Node.js
](sample-app.nodejs.md)
+ [
# Schritt 1: Erstellen Sie ein neues Hauptbuch
](getting-started.nodejs.step-1.md)
+ [
# Schritt 2: Testen Sie die Konnektivität zum Ledger
](getting-started.nodejs.step-2.md)
+ [
# Schritt 3: Erstellen Sie Tabellen, Indizes und Beispieldaten
](getting-started.nodejs.step-3.md)
+ [
# Schritt 4: Fragen Sie die Tabellen in einem Hauptbuch ab
](getting-started.nodejs.step-4.md)
+ [
# Schritt 5: Dokumente in einem Ledger ändern
](getting-started.nodejs.step-5.md)
+ [
# Schritt 6: Den Revisionsverlauf für ein Dokument anzeigen
](getting-started.nodejs.step-6.md)
+ [
# Schritt 7: Überprüfen Sie ein Dokument in einem Hauptbuch
](getting-started.nodejs.step-7.md)
+ [
# Schritt 8 (optional): Ressourcen bereinigen
](getting-started.nodejs.step-8.md)
# Installation der Amazon QLDB-Beispielanwendung Node.js
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
In diesem Abschnitt wird beschrieben, wie Sie die bereitgestellte Amazon QLDB-Beispielanwendung für das Tutorial step-by-step Node.js installieren und ausführen. Der Anwendungsfall für diese Beispielanwendung ist eine Datenbank der Straßenverkehrsbehörde, mit der die vollständigen Verlaufsinformationen über Fahrzeugzulassungen nachverfolgt werden.
Die DMV-Beispielanwendung für Node.js ist Open Source im GitHub Repository [amazon-qldb-dmv-sampleaws-samples/](https://github.com/aws-samples/amazon-qldb-dmv-sample-nodejs) -nodejs.
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie den QLDB-Treiber für Node.js fertiggestellt haben. [Voraussetzungen](getting-started.nodejs.md#getting-started.nodejs.prereqs) Dazu gehört die Installation von Node.js und die folgenden Schritte:
1. Melde dich an für AWS.
1. Erstellen Sie einen Benutzer mit den entsprechenden QLDB-Berechtigungen.
1. Gewähren Sie programmatischen Zugriff für die Entwicklung.
Um alle Schritte in diesem Tutorial ausführen zu können, benötigen Sie vollen Administratorzugriff auf Ihre Ledger-Ressource über die QLDB-API.
## Installation
**So installieren Sie die Beispielanwendung**
1. Geben Sie den folgenden Befehl ein, um die Beispielanwendung von zu klonen. GitHub
------
#### [ 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
```
------
Die Beispielanwendung packt den vollständigen Quellcode aus diesem Tutorial und seine Abhängigkeiten, einschließlich des Treibers Node.js und des [AWS SDK für JavaScript in Node.js](https://aws.amazon.com/sdk-for-node-js). Diese Anwendung ist in geschrieben TypeScript.
1. Wechseln Sie zu dem Verzeichnis, in dem das `amazon-qldb-dmv-sample-nodejs`-Paket geklont wird.
```
cd amazon-qldb-dmv-sample-nodejs
```
1. Führen Sie eine Neueinstallation der Abhängigkeiten durch.
```
npm ci
```
1. Transpilieren Sie das Paket.
```
npm run build
```
Die transpilierten JavaScript Dateien werden in das `./dist` Verzeichnis geschrieben.
1. Fahren Sie mit [Schritt 1: Erstellen Sie ein neues Hauptbuch](getting-started.nodejs.step-1.md) fort, um das Tutorial zu starten und ein Ledger zu erstellen.
# Schritt 1: Erstellen Sie ein neues Hauptbuch
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
In diesem Schritt erstellen Sie ein neues Amazon QLDB-Ledger mit dem Namen. `vehicle-registration`
**So erstellen Sie einen neuen Ledger**
1. Überprüfen Sie die folgende Datei (`Constants.ts`), die konstante Werte enthält, die von allen anderen Programmen in diesem Tutorial verwendet werden.
```
/*
* 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. Verwenden Sie das folgende Programm (`CreateLedger.ts`), um einen Ledger mit dem Namen `vehicle-registration` zu erstellen.
```
/*
* 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();
}
```
**Anmerkung**
Im `createLedger`-Aufruf müssen Sie einen Ledger-Namen und einen Berechtigungsmodus angeben. Wir empfehlen, den `STANDARD` Berechtigungsmodus zu verwenden, um die Sicherheit Ihrer Ledger-Daten zu maximieren.
Wenn Sie einen Ledger erstellen, ist der *Löschschutz* standardmäßig aktiviert. Dies ist eine Funktion in QLDB, die verhindert, dass Ledger von Benutzern gelöscht werden. Sie haben die Möglichkeit, den Löschschutz bei der Ledger-Erstellung mithilfe der QLDB-API oder der () zu deaktivieren. AWS Command Line Interface AWS CLI
Optional können Sie auch Tags angeben, die Ihrem Ledger angefügt werden sollen.
1. Geben Sie den folgenden Befehl ein, um das transpilierte Programm auszuführen.
```
node dist/CreateLedger.js
```
Fahren Sie zum Überprüfen der Verbindung mit dem neuen Ledger mit [Schritt 2: Testen Sie die Konnektivität zum Ledger](getting-started.nodejs.step-2.md) fort.
# Schritt 2: Testen Sie die Konnektivität zum Ledger
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
In diesem Schritt überprüfen Sie, ob Sie über den Transaktionsdaten-API-Endpunkt eine Verbindung zum `vehicle-registration` Ledger in Amazon QLDB herstellen können.
**So testen Sie die Verbindung zum Ledger**
1. Verwenden Sie das folgende Programm (`ConnectToLedger.ts`), um eine Datensitzungsverbindung mit dem Ledger `vehicle-registration` zu erstellen.
------
#### [ 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();
}
```
------
**Anmerkung**
Um Datentransaktionen in Ihrem Ledger auszuführen, müssen Sie ein QLDB-Treiberobjekt erstellen, um eine Verbindung zu einem bestimmten Ledger herzustellen. Dies ist ein anderes Client-Objekt als das `qldbClient`-Objekt, das Sie im [vorherigen Schritt](getting-started.nodejs.step-1.md) zum Erstellen des Ledgers verwendet haben. Dieser vorherige Client wird nur verwendet, um die in der aufgeführten Verwaltungs-API-Operationen auszuführen. [Amazon QLDB API-Referenz](api-reference.md)
1. Geben Sie den folgenden Befehl ein, um das transpilierte Programm auszuführen.
```
node dist/ConnectToLedger.js
```
Fahren Sie zum Erstellen von Tabellen im `vehicle-registration`-Ledger mit [Schritt 3: Erstellen Sie Tabellen, Indizes und Beispieldaten](getting-started.nodejs.step-3.md) fort.
# Schritt 3: Erstellen Sie Tabellen, Indizes und Beispieldaten
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
Wenn Ihr Amazon QLDB-Ledger aktiv ist und Verbindungen akzeptiert, können Sie damit beginnen, Tabellen mit Daten über Fahrzeuge, deren Besitzer und deren Zulassungsinformationen zu erstellen. Nach dem Erstellen der Tabellen und Indizes können Sie Daten in diese laden.
In diesem Schritt erstellen Sie vier Tabellen im `vehicle-registration`-Ledger:
+ `VehicleRegistration`
+ `Vehicle`
+ `Person`
+ `DriversLicense`
Außerdem erzeugen Sie die folgenden Indizes.
****
| Tabellenname | Feld |
| --- | --- |
| VehicleRegistration | VIN |
| VehicleRegistration | LicensePlateNumber |
| Vehicle | VIN |
| Person | GovId |
| DriversLicense | LicenseNumber |
| DriversLicense | PersonId |
Beim Einfügen von Beispieldaten fügen Sie zunächst Dokumente in die `Person`-Tabelle ein. Anschließend verwenden Sie die vom System zugewiesene `id` aus den `Person`-Dokumenten, um die entsprechenden Felder in den relevanten `VehicleRegistration`- und `DriversLicense`-Dokumenten auszufüllen.
**Tipp**
Es hat sich bewährt, das vom System zugewiesene `id` Dokument als Fremdschlüssel zu verwenden. Sie können zwar Felder definieren, die eindeutige Kennungen (z. B. eine Kfz-VIN) sein sollen, die echte eindeutige Kennung eines Dokuments ist aber seine `id`. Dieses Feld ist in den Metadaten des Dokuments enthalten, die Sie in der *festgeschriebenen Ansicht* (d. h. in der vom System definierten Ansicht der Tabelle) abrufen können.
Weitere Hinweise zu Ansichten in QLDB finden Sie unter. [Schlüsselkonzepte](ledger-structure.md) Weitere Informationen zu Metadaten finden Sie unter [Metadaten von Dokumenten werden abgefragt](working.metadata.md).
**So erstellen Sie Tabellen und Indizes**
1. Verwenden Sie das folgende Programm (`CreateTable.ts`), um die oben genannten Tabellen zu erstellen.
```
/*
* 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();
}
```
**Anmerkung**
Dieses Programm demonstriert, wie die `executeLambda` Funktion in einer QLDB-Treiberinstanz verwendet wird. In diesem Beispiel führen Sie mehrere `CREATE TABLE`-PartiQL-Anweisungen mit einem einzelnen Lambda-Ausdruck aus.
Diese Ausführungsfunktion startet implizit eine Transaktion, führt alle Anweisungen im Lambda aus und schreibt dann die Transaktion automatisch fest.
1. Geben Sie den folgenden Befehl ein, um das transpilierte Programm auszuführen.
```
node dist/CreateTable.js
```
1. Verwenden Sie das folgende Programm (`CreateIndex.ts`), um wie zuvor beschrieben Indizes für die Tabellen zu erstellen.
```
/*
* 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. Geben Sie den folgenden Befehl ein, um das transpilierte Programm auszuführen.
```
node dist/CreateIndex.js
```
**So laden Sie Daten in die Tabellen**
1. Überprüfen Sie die folgenden `.ts`-Dateien:
1. `SampleData.ts`— Enthält die Beispieldaten, die Sie in die Tabellen einfügen. `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 { 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`— Ein Hilfsmodul, das aus dem `ion-js` Paket importiert, um Hilfsfunktionen bereitzustellen, die [Amazon Ion-Daten](ion.md) konvertieren, analysieren und drucken.
```
/*
* 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)}.`);
}
}
```
**Anmerkung**
Die `getDocumentId` Funktion führt eine Abfrage aus, die ein vom System zugewiesenes Dokument IDs aus einer Tabelle zurückgibt. Weitere Informationen hierzu finden Sie unter [Verwenden der BY-Klausel zur Abfrage der Dokument-ID](working.metadata.by-clause.md).
1. Verwenden Sie das folgende Programm (`InsertDocument.ts`), um Beispieldaten in Ihre Tabellen einzufügen.
```
/*
* 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();
}
```
**Anmerkung**
Dieses Programm veranschaulicht, wie die `execute`-Funktion mit parametrisierten Werten aufgerufen wird. Zusätzlich zu der PartiQL-Anweisung, die Sie ausführen möchten, können Sie Datenparameter übergeben. Verwenden Sie ein Fragezeichen (`?`) als Variablenplatzhalter in Ihrer Anweisungszeichenfolge.
Wenn eine `INSERT`-Anweisung erfolgreich ist, wird die `id` jedes eingefügten Dokuments zurückgegeben.
1. Geben Sie den folgenden Befehl ein, um das transpilierte Programm auszuführen.
```
node dist/InsertDocument.js
```
Als Nächstes können Sie mit `SELECT`-Anweisungen Daten aus den Tabellen im `vehicle-registration`-Ledger lesen. Fahren Sie mit [Schritt 4: Fragen Sie die Tabellen in einem Hauptbuch ab](getting-started.nodejs.step-4.md) fort.
# Schritt 4: Fragen Sie die Tabellen in einem Hauptbuch ab
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
Nachdem Sie Tabellen in einem Amazon QLDB-Ledger erstellt und mit Daten geladen haben, können Sie Abfragen ausführen, um die gerade eingegebenen Fahrzeugregistrierungsdaten zu überprüfen. QLDB verwendet [PartiQL](ql-reference.md) als Abfragesprache und [Amazon Ion](ion.md) als dokumentenorientiertes Datenmodell.
PartiQL ist eine SQL-kompatible Open-Source-Abfragesprache, die für die Verwendung mit Ion erweitert wurde. Mit PartiSQL können Sie Ihre Daten mit vertrauten SQL-Operatoren einfügen, abfragen und verwalten. Amazon Ion ist eine Obermenge von JSON. Ion ist ein dokumentenbasiertes Open-Source-Datenformat, das Ihnen die Flexibilität bietet, strukturierte, halbstrukturierte und verschachtelte Daten zu speichern und zu verarbeiten.
In diesem Schritt verwenden Sie `SELECT`-Anweisungen zum Lesen von Daten aus den Tabellen im `vehicle-registration`-Ledger.
**Warnung**
Wenn Sie eine Abfrage in QLDB ohne indizierte Suche ausführen, wird ein vollständiger Tabellenscan aufgerufen. PartiQL unterstützt solche Abfragen, weil es SQL-kompatibel ist. Führen *Sie jedoch keine* Tabellenscans für Produktionsanwendungsfälle in QLDB aus. Tabellenscans können bei großen Tabellen zu Leistungsproblemen führen, einschließlich Parallelitätskonflikten und Transaktions-Timeouts.
Um Tabellenscans zu vermeiden, müssen Sie Anweisungen mit einer `WHERE` Prädikatklausel ausführen, indem Sie einen *Gleichheitsoperator* für ein indiziertes Feld oder eine Dokument-ID verwenden, z. B. oder. `WHERE indexedField = 123` `WHERE indexedField IN (456, 789)` Weitere Informationen finden Sie unter [Optimieren der Abfrageleistung](working.optimize.md).
**So fragen Sie die Tabellen ab**
1. Verwenden Sie das folgende Programm (`FindVehicles.ts`), um alle Fahrzeuge abzufragen, die für eine Person in Ihrem Ledger zugelassen sind.
```
/*
* 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();
}
```
**Anmerkung**
Zunächst fragt dieses Programm die `Person`-Tabelle nach dem Dokument mit `GovId LEWISR261LL` ab, um sein `id`-Metadatenfeld abzurufen.
Anschließend verwendet es dieses Dokument `id` als Fremdschlüssel, um die `VehicleRegistration`-Tabelle nach `PrimaryOwner.PersonId` abzufragen. Es tritt führt außerdem `VehicleRegistration` mit der `Vehicle`-Tabelle im `VIN`-Feld zusammen.
1. Geben Sie den folgenden Befehl ein, um das transpilierte Programm auszuführen.
```
node dist/FindVehicles.js
```
Weitere Informationen zum Ändern von Dokumenten in den Tabellen im `vehicle-registration`-Ledger finden Sie unter [Schritt 5: Dokumente in einem Ledger ändern](getting-started.nodejs.step-5.md).
# Schritt 5: Dokumente in einem Ledger ändern
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
Da Sie nun über Daten verfügen, mit denen Sie arbeiten können, können Sie damit beginnen, Änderungen an Dokumenten im `vehicle-registration` Hauptbuch in Amazon QLDB vorzunehmen. In diesem Schritt verdeutlichen die folgenden Codebeispiele, wie Sie Data Manipulation Language (DML)-Anweisungen ausführen. Diese Anweisungen aktualisieren den primären Eigentümer eines Fahrzeugs und fügen einem anderen Fahrzeug einen sekundären Eigentümer hinzu.
**So ändern Sie Dokumente**
1. Verwenden Sie das folgende Programm (`TransferVehicleOwnership.ts`), um den primären Besitzer des Fahrzeugs mit VIN `1N4AL11D75C109151` in Ihrem Ledger zu aktualisieren.
```
/*
* 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. Geben Sie den folgenden Befehl ein, um das transpilierte Programm auszuführen.
```
node dist/TransferVehicleOwnership.js
```
1. Verwenden Sie das folgende Programm (`AddSecondaryOwner.ts`), um dem Fahrzeug mit VIN `KM8SRDHF6EU074761` in Ihrem Ledger einen sekundären Besitzer hinzuzufügen.
```
/*
* 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. Geben Sie den folgenden Befehl ein, um das transpilierte Programm auszuführen.
```
node dist/AddSecondaryOwner.js
```
Informationen zum Überprüfen dieser Änderungen im `vehicle-registration`-Ledger finden Sie unter [Schritt 6: Den Revisionsverlauf für ein Dokument anzeigen](getting-started.nodejs.step-6.md).
# Schritt 6: Den Revisionsverlauf für ein Dokument anzeigen
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
Nach dem Bearbeiten der Zulassungsdaten für ein Fahrzeug im [vorherigen Schritt](getting-started.nodejs.step-5.md) können Sie den Verlauf aller registrierten Eigentümer und alle anderen aktualisierten Felder abfragen. In diesem Schritt führen Sie eine Abfrage des Revisionsverlaufs eines Dokuments in der `VehicleRegistration`-Tabelle in Ihrem `vehicle-registration`-Ledger durch.
**So zeigen Sie den Revisionsverlauf an**
1. Verwenden Sie das folgende Programm (`QueryHistory.ts`), um den Versionsverlauf des `VehicleRegistration`-Dokuments mit VIN `1N4AL11D75C109151` abzufragen.
```
/*
* 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();
}
```
**Anmerkung**
Sie können den Revisionsverlauf eines Dokuments anzeigen, indem Sie die integrierte [Funktion „Verlauf“](working.history.md#working.history.function) in der folgenden Syntax abfragen.
```
SELECT * FROM history( table_name [, `start-time` [, `end-time` ] ] ) AS h
[ WHERE h.metadata.id = 'id' ]
```
*Die *Startzeit und die Endzeit sind beide optional*.* Es handelt sich um Amazon Ion-Literalwerte, die mit Backticks () bezeichnet werden können. ``...`` Weitere Informationen finden Sie unter [Abfragen von Ion mit PartiQL in Amazon QLDB](ql-reference.query.md).
Es hat sich bewährt, eine Verlaufsabfrage sowohl mit einem Datumsbereich (*Start- und *Endzeit*) als auch mit einer Dokument-ID* () zu qualifizieren. `metadata.id` QLDB verarbeitet `SELECT` Abfragen in Transaktionen, die einem [Transaktions-Timeout-Limit](limits.md#limits.fixed) unterliegen.
Der QLDB-Verlauf wird nach Dokument-ID indexiert, und Sie können derzeit keine zusätzlichen Verlaufsindizes erstellen. Bei Verlaufsabfragen, die eine Start- und Endzeit enthalten, wird der Vorteil einer Qualifizierung nach einem bestimmten Zeitraum genutzt.
1. Geben Sie den folgenden Befehl ein, um das transpilierte Programm auszuführen.
```
node dist/QueryHistory.js
```
Fahren Sie zum kryptografischen Überprüfen einer Dokumentrevision im `vehicle-registration`-Ledger mit [Schritt 7: Überprüfen Sie ein Dokument in einem Hauptbuch](getting-started.nodejs.step-7.md) fort.
# Schritt 7: Überprüfen Sie ein Dokument in einem Hauptbuch
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
Mit Amazon QLDB können Sie die Integrität eines Dokuments im Journal Ihres Hauptbuchs effizient überprüfen, indem Sie kryptografisches Hashing mit SHA-256 verwenden. Weitere Informationen darüber, wie Verifizierung und kryptografisches Hashing in QLDB funktionieren, finden Sie unter. [Datenüberprüfung in Amazon QLDB](verification.md)
In diesem Schritt überprüfen Sie eine Dokumentrevision in der Tabelle `VehicleRegistration` in Ihrem `vehicle-registration`-Ledger. Zuerst fordern Sie einen Digest an, der als Ausgabedatei zurückgegeben wird und als Signatur des gesamten Änderungsverlaufs Ihres Ledgers fungiert. Anschließend fordern Sie einen Nachweis für die Revision in Bezug auf diesen Digest an. Mit diesem Nachweis wird die Integrität Ihrer Revision verifiziert, wenn alle Validierungsprüfungen bestanden werden.
**So überprüfen Sie eine Dokumentrevision**
1. Überprüfen Sie die folgenden `.ts` Dateien, die die QLDB-Objekte enthalten, die für die Überprüfung erforderlich sind.
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. Verwenden Sie zwei `.ts`-Programme (`GetDigest.ts` und `GetRevision.ts`), um die folgenden Schritte auszuführen:
+ Fordern Sie einen neuen Digest aus dem Ledger `vehicle-registration` an.
+ Fordern Sie einen Nachweis für jede Revision des Dokuments mit VIN `1N4AL11D75C109151` aus der `VehicleRegistration`-Tabelle an.
+ Überprüfen Sie die Revisionen mit dem zurückgegebenen Digest und dem Nachweis, indem Sie den Digest neu berechnen.
Das Programm `GetDigest.ts` enthält den folgenden Code.
```
/*
* 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();
}
```
**Anmerkung**
Verwenden Sie die `getDigest`-Funktion, um einen Digest anzufordern, der die aktuelle *Spitze* des Journals in Ihrem Ledger abdeckt. Der Tipp des Journals bezieht sich auf den letzten festgeschriebenen Block zu dem Zeitpunkt, zu dem QLDB Ihre Anfrage erhält.
Das Programm `GetRevision.ts` enthält den folgenden Code.
```
/*
* 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();
}
```
**Anmerkung**
Nachdem die `getRevision`-Funktion einen Nachweis für die angegebene Dokumentrevision zurückgibt, verwendet dieses Programm eine clientseitige API, um diese Revision zu überprüfen.
1. Geben Sie den folgenden Befehl ein, um das transpilierte Programm auszuführen.
```
node dist/GetRevision.js
```
Wenn Sie den `vehicle-registration`-Ledger nicht mehr verwenden müssen, fahren Sie mit [Schritt 8 (optional): Ressourcen bereinigen](getting-started.nodejs.step-8.md) fort.
# Schritt 8 (optional): Ressourcen bereinigen
**Wichtig**
Hinweis zum Ende des Supports: Bestandskunden können Amazon QLDB bis zum Ende des Supports am 31.07.2025 nutzen. Weitere Informationen finden Sie unter [Migrieren eines Amazon QLDB-Ledgers zu Amazon](https://aws.amazon.com/blogs/database/migrate-an-amazon-qldb-ledger-to-amazon-aurora-postgresql/) Aurora PostgreSQL.
Sie können den `vehicle-registration`-Ledger weiterhin verwenden. Wenn Sie ihn nicht mehr benötigen, sollten Sie ihn jedoch löschen.
**So löschen Sie den Ledger**
1. Verwenden Sie das folgende Programm (`DeleteLedger.ts`), um Ihren `vehicle-registration`-Ledger und all seine Inhalte zu löschen.
```
/*
* 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();
}
```
**Anmerkung**
Wenn der Löschschutz für Ihr Ledger aktiviert ist, müssen Sie ihn zuerst deaktivieren, bevor Sie das Ledger mithilfe der QLDB-API löschen können.
1. Geben Sie den folgenden Befehl ein, um das transpilierte Programm auszuführen.
```
node dist/DeleteLedger.js
```