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.

# Node.js und DAX
<a name="DAX.client.run-application-nodejs-3"></a>

# Standard-Client-Konfiguration für Node.js
<a name="DAX-client-config-JS"></a>

Bei der Konfiguration des DAX JavaScript SDK-Clients können Sie verschiedene Parameter anpassen, um Leistung, Verbindungsbehandlung und Fehlerresistenz zu optimieren. In der folgenden Tabelle werden die Standardkonfigurationseinstellungen beschrieben, mit denen gesteuert wird, wie Ihr Client mit dem DAX-Cluster interagiert, u. a. Timeout-Werte, Wiederholungsmechanismen, Verwaltung von Anmeldeinformationen und Optionen zur Systemüberwachung. Weitere Informationen finden Sie unter [Dynamo DBClient Operations](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/dynamodb/).


**Standardeinstellungen für den DAX-JS-SDK-Client**  

| Parameter | Typ | Description | 
| --- | --- | --- | 
|  `region` optional  |  `string`  |  Der für den DAX-Client AWS-Region zu verwendende (Beispiel - 'us-east-1'). Dies ist ein erforderlicher Parameter, sofern er nicht über die Umgebungsvariable bereitgestellt wird.  | 
|  `endpoint` Erforderlich  |  `string`  | Der Endpunkt des Clusters, mit dem das SDK eine Verbindung herstellt. Beispiele: Unverschlüsselt — .region.amazonaws.com dax-cluster-name Verschlüsselt – daxs://Mein-Cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com  | 
|  `requestTimeout` Standard: 6 000 ms  |  `number`  | Dies definiert die maximale Zeit, die der Client auf eine Antwort von DAX wartet.  | 
|  `writeRetries` Standard: 1  |  `number`  | Die Anzahl der Wiederholungsversuche für fehlgeschlagene Schreibanforderungen.  | 
|  `readRetries` Standard: 1  |  `number`  | Die Anzahl der Wiederholungsversuche für fehlgeschlagene Leseanforderungen.  | 
|  `maxRetries` Standard: 1  |  `number`  | Die maximale Anzahl von Versuchen bei fehlgeschlagenen Anforderungen. Wenn festgelegt readRetries/writeRetries sind, hat die in ReadRetries und WriteRetries festgelegte Konfiguration Vorrang vor MaxRetries.  | 
|  `connectTimeout` Standard: 10 000 ms  |  `number`  | Das Timeout (in Millisekunden) für das Herstellen einer Verbindung zu einem der Cluster-Knoten.  | 
|  `maxConcurrentConnections` Standard: 100  |  `number`  | Beschränkt die Gesamtzahl der gleichzeitigen Verbindungen, die eine Client-Instance pro Knoten in einem DAX-Cluster herstellen kann.  | 
|  `maxRetryDelay` Standard: 7 000 ms  |  `number`  | Wenn der DAX-Server angibt, dass eine Wiederherstellung erforderlich ist, indem das `waitForRecoveryBeforeRetrying`-Flag auf „true“ gesetzt wird, hält der Client an, bevor er es erneut versucht. Während dieser Wiederherstellungsperioden bestimmt der `maxRetryDelay`-Parameter die maximale Wartezeit zwischen Wiederholungsversuchen. Diese für die Wiederherstellung spezifische Konfiguration gilt nur, wenn sich der DAX-Server im Wiederherstellungsmodus befindet. In allen anderen Szenarien folgt das Wiederholungsverhalten einem von zwei Mustern: entweder einer exponentiellen Verzögerung auf der Grundlage der Anzahl der Wiederholungen (bestimmt durch den Parameter `writeRetries`, `readRetries` oder `maxRetries`) oder einer sofortigen Wiederholung, abhängig vom Ausnahmetyp.  | 
|  `credentials` optional  |  `[AwsCredentialIdentity](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/)` \$1 `[AwsCredentialIdentityProvider](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/)`  |  Die AWS Anmeldeinformationen, die für die Authentifizierung von Anfragen verwendet werden sollen. Dies kann als AwsCredentialIdentity oder als angegeben werden. AwsCredentialIdentityProvider Wenn nicht angegeben, verwendet das AWS -SDK automatisch die standardmäßige Anbieterkette für Anmeldeinformationen. Beispiel: `\$1 accessKeyId: 'AKIA... ' , secretAccessKey: ' ... ', sessionToken:'... '\$1 `\$1 @default Verwendet die Standard-Anbieterkette AWS für Anmeldeinformationen.  | 
|  `healthCheckInterval` Standard: 5 000 ms  |  `number`  | Das Intervall (in Millisekunden) zwischen den Cluster-Zustandsprüfungen. Bei einem kürzeren Intervall werden die Prüfungen häufiger durchgeführt.  | 
|  `healthCheckTimeout` Standard: 1 000 ms  |  `number`  | Das Timeout (in Millisekunden) für den Abschluss der Zustandsprüfung.  | 
|  `skipHostnameVerification` Standard: falsch  |  `boolean`  |  Die Hostnamen-Überprüfung von TLS-Verbindungen wird übersprungen. Dies hat keine Auswirkungen auf unverschlüsselte Cluster. Standardmäßig wird die Überprüfung des Hostnamens durchgeführt. Wenn Sie diesen Wert auf „True“ setzen, wird die Überprüfung übersprungen. Sie müssen sich bewusst sein, welche Folgen eine Deaktivierung hat, d. h. dass der Cluster, zu dem Sie eine Verbindung herstellen, nicht authentifiziert werden kann.   | 
|  `unhealthyConsecutiveErrorCount` Standard: 5  |  `number`  | Legt die Anzahl aufeinanderfolgender Fehler fest, die erforderlich sind, um innerhalb des Intervalls für die Zustandsprüfung zu signalisieren, dass der Knoten fehlerhaft ist.  | 
|  `clusterUpdateInterval` Standard: 4 000 ms  |  `number`  | Gibt das Intervall zwischen der Abfrage von Mitgliedschaftsänderungen bei Cluster-Mitgliedern zurück.  | 
|  `clusterUpdateThreshold` Standard: 125  |  `number`  | Gibt den Schwellenwert zurück, unter dem der Cluster nicht nach Mitgliedschaftsänderungen abgefragt wird.  | 
|  `credentailProvider` optional \$1 Standard null  |  `[AwsCredentialIdentityProvider](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/)`  | Benutzerdefinierter Anbieter für AWS Anmeldeinformationen, die zur Authentifizierung von Anfragen an DAX verwendet werden.  | 


**Paginierungskonfiguration für DaxDocument**  

| Name | Typ | Detail | 
| --- | --- | --- | 
|  `client`  |  DaxDocument  |  Instanz des DaxDocument Typs.  | 
|  `pageSize`  |  number  |  Bestimmt die Anzahl der Elemente pro Seite.  | 
|  `startingToken` Optional  |  any  |  LastEvaluatedKey aus der vorherigen Antwort kann für nachfolgende Anfragen verwendet werden.  | 

Informationen zur Verwendung der Paginierung finden Sie unter [TryDax.js](DAX.client.tutorial-TryDax.md).

# Migration zum DAX-Node.js-SDK V3
<a name="DAX.client.run-application-nodejs-3-migrating"></a>

Dieser Migrationsleitfaden hilft Ihnen bei der Umstellung Ihrer vorhandenen DAX-Node.js-Anwendungen. Das neue SDK erfordert Node.js 18 oder höher und führt mehrere wichtige Änderungen in der Strukturierung Ihres DynamoDB-Accelerator-Codes ein. Dieser Leitfaden führt Sie durch die wichtigsten Unterschiede, darunter Syntaxänderungen, neue Importmethoden und aktualisierte asynchrone Programmiermuster.

## Verwendung von V2 Node.js DAX
<a name="DAX.client.run-application-nodejs-3-migrating-V2-usage"></a>

```
const AmazonDaxClient = require('amazon-dax-client');
const AWS = require('aws-sdk');

var region = "us-west-2";

AWS.config.update({
  region: region,
});

var client = new AWS.DynamoDB.DocumentClient();

if (process.argv.length > 2) {
  var dax = new AmazonDaxClient({
    endpoints: [process.argv[2]],
    region: region,
  });
  client = new AWS.DynamoDB.DocumentClient({ service: dax });
}

// Make Get Call using Dax
var params = {
    TableName: 'TryDaxTable',
    pk: 1,
    sk: 1
}
client.get(params, function (err, data) {
    if (err) {
        console.error(
            "Unable to read item. Error JSON:",
            JSON.stringify(err, null, 2)
          );
    } else {
        console.log(data);
    }
});
```

## Verwendung von V3 Node.js DAX
<a name="DAX.client.run-application-nodejs-3-migrating-V3-dax-usage"></a>

Für die Verwendung von DAX Node.js ist V3-Node-Version 18 oder höher die bevorzugte Version. Um zu Node 18 zu wechseln, verwenden Sie Folgendes:

```
import { DaxDocument } from '@amazon-dax-sdk/lib-dax';
import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';

let client: DynamoDBDocument | DaxDocument = DynamoDBDocument.from(
  new DynamoDBClient({ region: 'us-west-2' })
);

if (process.argv.length > 2) {
  client = new DaxDocument({
    endpoints: [process.argv[2]],
    region: 'us-west-2',
  });
}

const params = {
  TableName: 'TryDaxTable',
  Key: { pk: 1, sk: 1 },
};

try {
  const results = await client.get(params);
  console.log(results);
} catch (err) {
  console.error(err);
}
```

Das DAX-SDK für Node.js v3.x ist mit dem [AWS -SDK für Node.js v3.x](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/introduction/) kompatibel. Das DAX-SDK für Node.js v3.x unterstützt die Verwendung [aggregierter](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/introduction/#high-level-concepts) Clients. Beachten Sie, dass DAX die Erstellung von Bare-Bone-Clients nicht unterstützt. Weitere Informationen zu nicht unterstützten Funktionen finden Sie unter [Funktionen, die nicht mit AWS SDK V3 identisch sind](#DAX.client.run-application-nodejs-3-not-in-parity).

Um die Node.js-Beispielanwendung auf Ihrer Amazon-EC2-Instance auszuführen, gehen Sie wie folgt vor.

**So führen Sie das Node.js-Beispiel für DAX aus**

1. Richten Sie Node.js auf Ihrer Amazon-EC2-Instance wie folgt ein:

   1. Installieren Sie den Node Version Manager (`nvm`).

      ```
      curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
      ```

   1. Installieren Sie Node.js mit dem nvm.

      ```
      nvm install 18
      ```

   1. Verwenden Sie nvm, um Node 18 zu verwenden.

      ```
      nvm use 18
      ```

   1. Testen Sie, ob Node.js installiert ist und ordnungsgemäß ausgeführt wird.

      ```
      node -e "console.log('Running Node.js ' + process.version)"
      ```

      Die folgende Meldung sollte angezeigt werden.

      `Running Node.js v18.x.x`

1. Installieren Sie den Client DaxDocument Node.js mit dem Node Package Manager (`npm`).

   ```
   npm install @amazon-dax-sdk/lib-dax
   ```

## TryDax Beispielcode
<a name="DAX.client.run-application-nodejs-3-TryDax-sample-code"></a>

Wenn Sie die Leistungsvorteile von DynamoDB Accelerator (DAX) bewerten möchten, gehen Sie wie folgt vor, um einen Beispieltest durchzuführen, bei dem die Lesevorgangszeiten zwischen Standard-DynamoDB und einem DAX-Cluster verglichen werden.

1. Nachdem Sie Ihren Workspace eingerichtet und `lib-dax` als Abhängigkeit hinzugefügt haben, kopieren Sie [TryDax.js](DAX.client.tutorial-TryDax.md) in Ihr Projekt.

1. Führen Sie das Programm für Ihren DAX-Cluster aus. Um den Endpunkt für Ihren DAX-Cluster zu bestimmen, wählen Sie einen der folgenden Schritte aus: 
   +  **Using the DynamoDB console** (Verwenden der DynamoDB-Konsole) — Wählen Sie Ihren DAX-Cluster aus. Der Cluster-Endpunkt wird auf der Konsole angezeigt, wie im folgenden Beispiel gezeigt.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Verwenden** Sie AWS CLI— Geben Sie den folgenden Befehl ein.

     ```
     aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"
     ```

     Der Cluster-Endpunkt wird in der Ausgabe angezeigt, wie im folgenden Beispiel gezeigt.

     ```
     {
         "Address": "my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com",
         "Port": 8111,
         "URL": "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
     }
     ```

1. Führen Sie jetzt das Programm aus, indem Sie den Cluster-Endpunkt als Befehlszeilenparameter angeben.

   ```
   node TryDax.js dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
   ```

   Die Ausgabe sollte folgendermaßen oder ähnlich aussehen:

   ```
   Attempting to create table; please wait...
   Successfully created table. Table status: ACTIVE
   Writing data to the table...
   Writing 20 items for partition key:  1
   Writing 20 items for partition key:  2
   Writing 20 items for partition key:  3
   ...
   Running GetItem Test
           Total time: 153555.10 µs - Avg time: 383.89 µs
           Total time: 44679.96 µs - Avg time: 111.70 µs
           Total time: 36885.86 µs - Avg time: 92.21 µs
           Total time: 32467.25 µs - Avg time: 81.17 µs
           Total time: 32202.60 µs - Avg time: 80.51 µs
   Running Query Test
           Total time: 14869.25 µs - Avg time: 2973.85 µs
           Total time: 3036.31 µs - Avg time: 607.26 µs
           Total time: 2468.92 µs - Avg time: 493.78 µs
           Total time: 2062.53 µs - Avg time: 412.51 µs
           Total time: 2178.22 µs - Avg time: 435.64 µs
   Running Scan Test
           Total time: 2395.88 µs - Avg time: 479.18 µs
           Total time: 2207.16 µs - Avg time: 441.43 µs
           Total time: 2443.14 µs - Avg time: 488.63 µs
           Total time: 2038.24 µs - Avg time: 407.65 µs
           Total time: 1972.17 µs - Avg time: 394.43 µs
   Running Pagination Test
   Scan Pagination
   [
     { pk: 1, sk: 1, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 2, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 3, someData: 'XXXXXXXXXX' }
   ]
   [
     { pk: 1, sk: 4, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 5, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 6, someData: 'XXXXXXXXXX' }
   ]
   ...
   Query Pagination
   [
     { pk: 1, sk: 1, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 2, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 3, someData: 'XXXXXXXXXX' }
   ]
   [
     { pk: 1, sk: 4, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 5, someData: 'XXXXXXXXXX' },
     { pk: 1, sk: 6, someData: 'XXXXXXXXXX' }
   ]
   ...
   Attempting to delete table; please wait...
   Successfully deleted table.
   ```

   Beachten Sie die Zeitinformationen. Die Anzahl der Mikrosekunden, die für die `GetItem`-, `Query`-, `Scan`-Tests benötigt werden.

1. In diesem Fall haben Sie die Programme für den DAX-Cluster ausgeführt. Jetzt führen Sie das Programm erneut aus, diesmal für DynamoDB.

1. Führen Sie nun das Programm erneut aus, diesmal aber ohne die Cluster-Endpunkt-URL als Befehlszeilenparameter.

   ```
   node TryDax.js
   ```

   Sehen Sie sich die Ausgabe an und notieren Sie die Zeitinformationen. Die verstrichene Zeit sollte für `GetItem`, `Query` und `Scan` mit DAX deutlich kürzer sein als mit DynamoDB.

## Funktionen, die nicht mit AWS SDK V3 identisch sind
<a name="DAX.client.run-application-nodejs-3-not-in-parity"></a>
+ [Bare-Bone](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/introduction/#high-level-concepts)-Clients: Dax Node.js V3 unterstützt keine Bare-Bone-Clients. 

  ```
  const dynamoDBClient = new DynamoDBClient({ region: 'us-west-2' });
  const regularParams = {
      TableName: 'TryDaxTable',
      Key: {
          pk: 1,
          sk: 1
      }
  };
  // The DynamoDB client supports the send operation.
  const dynamoResult = await dynamoDBClient.send(new GetCommand(regularParams));
  
  // However, the DaxDocument client does not support the send operation.
  const daxClient = new DaxDocument({
      endpoints: ['your-dax-endpoint'],
      region: 'us-west-2',
  });
  
  const params = {
      TableName: 'TryDaxTable',
      Key: {
          pk: 1,
          sk: 1
      }
  };
  
  // This will throw an error - send operation is not supported for DAX. Please refer to documentation.
  const result = await daxClient.send(new GetCommand(params));
  console.log(result);
  ```
+ [Middleware-Stack](https://aws.amazon.com/blogs/developer/middleware-stack-modular-aws-sdk-js/): Dax Node.js V3 unterstützt die Verwendung von Middleware-Funktionen nicht.

  ```
  const dynamoDBClient = new DynamoDBClient({ region: 'us-west-2' });
  // The DynamoDB client supports the middlewareStack.
  dynamoDBClient.middlewareStack.add(
    (next, context) =>> async (args) => {
      console.log("Before operation:", args);
      const result = await next(args);
      console.log("After operation:", result);
      return result;
    },
    {
      step: "initialize", // or "build", "finalizeRequest", "deserialize"
      name: "loggingMiddleware",
    }
  );
  
  // However, the DaxDocument client does not support the middlewareStack.
  const daxClient = new DaxDocument({
      endpoints: ['your-dax-endpoint'],
      region: 'us-west-2',
  });
  
  // This will throw an error - custom middleware and middlewareStacks are not supported for DAX. Please refer to documentation.
  daxClient.middlewareStack.add(
    (next, context) => async (args) => {
      console.log("Before operation:", args);
      const result = await next(args);
      console.log("After operation:", result);
      return result;
    },
    {
      step: "initialize", // or "build", "finalizeRequest", "deserialize"
      name: "loggingMiddleware",
    }
  );
  ```

# TryDax.js
<a name="DAX.client.tutorial-TryDax"></a>

```
import { DynamoDB, waitUntilTableExists, waitUntilTableNotExists } from "@aws-sdk/client-dynamodb";
import { DaxDocument, daxPaginateScan, daxPaginateQuery } from "@amazon-dax-sdk/lib-dax";
import { DynamoDBDocument, paginateQuery, paginateScan } from "@aws-sdk/lib-dynamodb";

const region = "us-east-1";
const tableName = "TryDaxTable";

// Determine the client (DynamoDB or DAX)
let client = DynamoDBDocument.from(new DynamoDB({ region }));
if (process.argv.length > 2) {
  client = new DaxDocument({ region, endpoint: process.argv[2] });
}

// Function to create table
async function createTable() {
  const dynamodb = new DynamoDB({ region });
  const params = {
    TableName: tableName,
    KeySchema: [
      { AttributeName: "pk", KeyType: "HASH" },
      { AttributeName: "sk", KeyType: "RANGE" },
    ],
    AttributeDefinitions: [
      { AttributeName: "pk", AttributeType: "N" },
      { AttributeName: "sk", AttributeType: "N" },
    ],
    ProvisionedThroughput: { ReadCapacityUnits: 25, WriteCapacityUnits: 25 },
  };

  try {
    console.log("Attempting to create table; please wait...");
    await dynamodb.createTable(params);
    await waitUntilTableExists({ client: dynamodb, maxWaitTime: 30 }, { TableName: tableName });
    console.log("Successfully created table. Table status: ACTIVE");
  } catch (err) {
    console.error("Error in table creation:", err);
  }
}

// Function to insert data
async function writeData() {
  console.log("Writing data to the table...");
  const someData = "X".repeat(10);
  for (let ipk = 1; ipk <= 20; ipk++) {
    console.log("Writing 20 items for partition key: ", ipk)
    for (let isk = 1; isk <= 20; isk++) {
      try {
        await client.put({ TableName: tableName, Item: { pk: ipk, sk: isk, someData } });
      } catch (err) {
        console.error("Error inserting data:", err);
      }
    }
  }
}

// Function to test GetItem
async function getItemTest() {
  console.log("Running GetItem Test");
  for (let i = 0; i < 5; i++) {
    const startTime = performance.now();
    const promises = [];
    for (let ipk = 1; ipk <= 20; ipk++) {
      for (let isk = 1; isk <= 20; isk++) {
        promises.push(client.get({ TableName: tableName, Key: { pk: ipk, sk: isk } }));
      }
    }
    await Promise.all(promises);
    const endTime = performance.now();
    const iterTime = (endTime - startTime) * 1000;
    const totalTime = iterTime.toFixed(2).padStart(3, ' ');
    const avgTime = (iterTime / 400).toFixed(2).padStart(3, ' ');
    console.log(`\tTotal time: ${totalTime} \u00B5s - Avg time: ${avgTime} \u00B5s`);
  }
}

// Function to test Query
async function queryTest() {
  console.log("Running Query Test");
  for (let i = 0; i < 5; i++) {
    const startTime = performance.now();
    const promises = [];
    for (let pk = 1; pk <= 5; pk++) {
      const params = {
        TableName: tableName,
        KeyConditionExpression: "pk = :pkval and sk between :skval1 and :skval2",
        ExpressionAttributeValues: { ":pkval": pk, ":skval1": 1, ":skval2": 2 },
      };
      promises.push(client.query(params));
    }
    await Promise.all(promises);
    const endTime = performance.now();
    const iterTime = (endTime - startTime) * 1000;
    const totalTime = iterTime.toFixed(2).padStart(3, ' ');
    const avgTime = (iterTime / 5).toFixed(2).padStart(3, ' ');
    console.log(`\tTotal time: ${totalTime} \u00B5s - Avg time: ${avgTime} \u00B5s`);
  }
}

// Function to test Scan
async function scanTest() {
  console.log("Running Scan Test");
  for (let i = 0; i < 5; i++) {
    const startTime = performance.now();
    const promises = [];
    for (let pk = 1; pk <= 5; pk++) {
      const params = {
        TableName: tableName,
        FilterExpression: "pk = :pkval and sk between :skval1 and :skval2",
        ExpressionAttributeValues: { ":pkval": pk, ":skval1": 1, ":skval2": 2 },
      };
      promises.push(client.scan(params));
    }
    await Promise.all(promises);
    const endTime = performance.now();
    const iterTime = (endTime - startTime) * 1000;
    const totalTime = iterTime.toFixed(2).padStart(3, ' ');
    const avgTime = (iterTime / 5).toFixed(2).padStart(3, ' ');
    console.log(`\tTotal time: ${totalTime} \u00B5s - Avg time: ${avgTime} \u00B5s`);
  }
}

// Function to test Pagination
async function paginationTest() {
  console.log("Running Pagination Test");
  console.log("Scan Pagination");
  const scanParams = { TableName: tableName };
  const paginator = process.argv.length > 2 ? daxPaginateScan : paginateScan;
  for await (const page of paginator({ client, pageSize: 3 }, scanParams)) {
    console.log(page.Items);
  }

  console.log("Query Pagination");
  const queryParams = {
    TableName: tableName,
    KeyConditionExpression: "pk = :pkval and sk between :skval1 and :skval2",
    ExpressionAttributeValues: { ":pkval": 1, ":skval1": 1, ":skval2": 10 },
  };
  const queryPaginator = process.argv.length > 2 ? daxPaginateQuery : paginateQuery;
  for await (const page of queryPaginator({ client, pageSize: 3 }, queryParams)) {
    console.log(page.Items);
  }
}

// Function to delete the table
async function deleteTable() {
  const dynamodb = new DynamoDB({ region });
  console.log("Attempting to delete table; please wait...")
  try {
    await dynamodb.deleteTable({ TableName: tableName });
    await waitUntilTableNotExists({ client: dynamodb, maxWaitTime: 30 }, { TableName: tableName });
    console.log("Successfully deleted table.");
  } catch (err) {
    console.error("Error deleting table:", err);
  }
}

// Execute functions sequentially
(async function () {
  await createTable();
  await writeData();
  await getItemTest();
  await queryTest();
  await scanTest();
  await paginationTest();
  await deleteTable();
})();
```