The AWS SDK for JavaScript V3 API Reference Guide describes in detail all the API operations for the AWS SDK for JavaScript version 3 (V3).
DynamoDB examples using SDK for JavaScript (v3)
The following code examples show you how to perform actions and implement common scenarios by using the AWS SDK for JavaScript (v3) with DynamoDB.
Basics are code examples that show you how to perform the essential operations within a service.
Actions are code excerpts from larger programs and must be run in context. While actions show you how to call individual service functions, you can see actions in context in their related scenarios.
Scenarios are code examples that show you how to accomplish specific tasks by calling multiple functions within a service or combined with other AWS services.
Each example includes a link to the complete source code, where you can find instructions on how to set up and run the code in context.
Get started
The following code examples show how to get started using DynamoDB.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. For more details on working with DynamoDB in AWS SDK for JavaScript, see Programming DynamoDB with JavaScript.
import { ListTablesCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb"; const client = new DynamoDBClient({}); export const main = async () => { const command = new ListTablesCommand({}); const response = await client.send(command); console.log(response.TableNames.join("\n")); return response; };
-
For API details, see ListTables in AWS SDK for JavaScript API Reference.
-
Basics
The following code example shows how to:
Create a table that can hold movie data.
Put, get, and update a single movie in the table.
Write movie data to the table from a sample JSON file.
Query for movies that were released in a given year.
Scan for movies that were released in a range of years.
Delete a movie from the table, then delete the table.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. import { readFileSync } from "node:fs"; import { BillingMode, CreateTableCommand, DeleteTableCommand, DynamoDBClient, waitUntilTableExists, } from "@aws-sdk/client-dynamodb"; /** * This module is a convenience library. It abstracts Amazon DynamoDB's data type * descriptors (such as S, N, B, and BOOL) by marshalling JavaScript objects into * AttributeValue shapes. */ import { BatchWriteCommand, DeleteCommand, DynamoDBDocumentClient, GetCommand, PutCommand, UpdateCommand, paginateQuery, paginateScan, } from "@aws-sdk/lib-dynamodb"; // These modules are local to our GitHub repository. We recommend cloning // the project from GitHub if you want to run this example. // For more information, see https://github.com/awsdocs/aws-doc-sdk-examples. import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js"; import { dirnameFromMetaUrl } from "@aws-doc-sdk-examples/lib/utils/util-fs.js"; import { chunkArray } from "@aws-doc-sdk-examples/lib/utils/util-array.js"; const dirname = dirnameFromMetaUrl(import.meta.url); const tableName = getUniqueName("Movies"); const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const log = (msg) => console.log(`[SCENARIO] ${msg}`); export const main = async () => { /** * Create a table. */ const createTableCommand = new CreateTableCommand({ TableName: tableName, // This example performs a large write to the database. // Set the billing mode to PAY_PER_REQUEST to // avoid throttling the large write. BillingMode: BillingMode.PAY_PER_REQUEST, // Define the attributes that are necessary for the key schema. AttributeDefinitions: [ { AttributeName: "year", // 'N' is a data type descriptor that represents a number type. // For a list of all data type descriptors, see the following link. // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html#Programming.LowLevelAPI.DataTypeDescriptors AttributeType: "N", }, { AttributeName: "title", AttributeType: "S" }, ], // The KeySchema defines the primary key. The primary key can be // a partition key, or a combination of a partition key and a sort key. // Key schema design is important. For more info, see // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html KeySchema: [ // The way your data is accessed determines how you structure your keys. // The movies table will be queried for movies by year. It makes sense // to make year our partition (HASH) key. { AttributeName: "year", KeyType: "HASH" }, { AttributeName: "title", KeyType: "RANGE" }, ], }); log("Creating a table."); const createTableResponse = await client.send(createTableCommand); log(`Table created: ${JSON.stringify(createTableResponse.TableDescription)}`); // This polls with DescribeTableCommand until the requested table is 'ACTIVE'. // You can't write to a table before it's active. log("Waiting for the table to be active."); await waitUntilTableExists({ client }, { TableName: tableName }); log("Table active."); /** * Add a movie to the table. */ log("Adding a single movie to the table."); // PutCommand is the first example usage of 'lib-dynamodb'. const putCommand = new PutCommand({ TableName: tableName, Item: { // In 'client-dynamodb', the AttributeValue would be required (`year: { N: 1981 }`) // 'lib-dynamodb' simplifies the usage ( `year: 1981` ) year: 1981, // The preceding KeySchema defines 'title' as our sort (RANGE) key, so 'title' // is required. title: "The Evil Dead", // Every other attribute is optional. info: { genres: ["Horror"], }, }, }); await docClient.send(putCommand); log("The movie was added."); /** * Get a movie from the table. */ log("Getting a single movie from the table."); const getCommand = new GetCommand({ TableName: tableName, // Requires the complete primary key. For the movies table, the primary key // is only the id (partition key). Key: { year: 1981, title: "The Evil Dead", }, // Set this to make sure that recent writes are reflected. // For more information, see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadConsistency.html. ConsistentRead: true, }); const getResponse = await docClient.send(getCommand); log(`Got the movie: ${JSON.stringify(getResponse.Item)}`); /** * Update a movie in the table. */ log("Updating a single movie in the table."); const updateCommand = new UpdateCommand({ TableName: tableName, Key: { year: 1981, title: "The Evil Dead" }, // This update expression appends "Comedy" to the list of genres. // For more information on update expressions, see // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html UpdateExpression: "set #i.#g = list_append(#i.#g, :vals)", ExpressionAttributeNames: { "#i": "info", "#g": "genres" }, ExpressionAttributeValues: { ":vals": ["Comedy"], }, ReturnValues: "ALL_NEW", }); const updateResponse = await docClient.send(updateCommand); log(`Movie updated: ${JSON.stringify(updateResponse.Attributes)}`); /** * Delete a movie from the table. */ log("Deleting a single movie from the table."); const deleteCommand = new DeleteCommand({ TableName: tableName, Key: { year: 1981, title: "The Evil Dead" }, }); await client.send(deleteCommand); log("Movie deleted."); /** * Upload a batch of movies. */ log("Adding movies from local JSON file."); const file = readFileSync( `${dirname}../../../../resources/sample_files/movies.json`, ); const movies = JSON.parse(file.toString()); // chunkArray is a local convenience function. It takes an array and returns // a generator function. The generator function yields every N items. const movieChunks = chunkArray(movies, 25); // For every chunk of 25 movies, make one BatchWrite request. for (const chunk of movieChunks) { const putRequests = chunk.map((movie) => ({ PutRequest: { Item: movie, }, })); const command = new BatchWriteCommand({ RequestItems: { [tableName]: putRequests, }, }); await docClient.send(command); } log("Movies added."); /** * Query for movies by year. */ log("Querying for all movies from 1981."); const paginatedQuery = paginateQuery( { client: docClient }, { TableName: tableName, //For more information about query expressions, see // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.KeyConditionExpressions KeyConditionExpression: "#y = :y", // 'year' is a reserved word in DynamoDB. Indicate that it's an attribute // name by using an expression attribute name. ExpressionAttributeNames: { "#y": "year" }, ExpressionAttributeValues: { ":y": 1981 }, ConsistentRead: true, }, ); /** * @type { Record<string, any>[] }; */ const movies1981 = []; for await (const page of paginatedQuery) { movies1981.push(...page.Items); } log(`Movies: ${movies1981.map((m) => m.title).join(", ")}`); /** * Scan the table for movies between 1980 and 1990. */ log("Scan for movies released between 1980 and 1990"); // A 'Scan' operation always reads every item in the table. If your design requires // the use of 'Scan', consider indexing your table or changing your design. // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-query-scan.html const paginatedScan = paginateScan( { client: docClient }, { TableName: tableName, // Scan uses a filter expression instead of a key condition expression. Scan will // read the entire table and then apply the filter. FilterExpression: "#y between :y1 and :y2", ExpressionAttributeNames: { "#y": "year" }, ExpressionAttributeValues: { ":y1": 1980, ":y2": 1990 }, ConsistentRead: true, }, ); /** * @type { Record<string, any>[] }; */ const movies1980to1990 = []; for await (const page of paginatedScan) { movies1980to1990.push(...page.Items); } log( `Movies: ${movies1980to1990 .map((m) => `${m.title} (${m.year})`) .join(", ")}`, ); /** * Delete the table. */ const deleteTableCommand = new DeleteTableCommand({ TableName: tableName }); log(`Deleting table ${tableName}.`); await client.send(deleteTableCommand); log("Table deleted."); };
-
For API details, see the following topics in AWS SDK for JavaScript API Reference.
-
Actions
The following code example shows how to use BatchExecuteStatement
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. Create a batch of items using PartiQL.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, BatchExecuteStatementCommand, } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const breakfastFoods = ["Eggs", "Bacon", "Sausage"]; const command = new BatchExecuteStatementCommand({ Statements: breakfastFoods.map((food) => ({ Statement: `INSERT INTO BreakfastFoods value {'Name':?}`, Parameters: [food], })), }); const response = await docClient.send(command); console.log(response); return response; };
Get a batch of items using PartiQL.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, BatchExecuteStatementCommand, } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new BatchExecuteStatementCommand({ Statements: [ { Statement: "SELECT * FROM PepperMeasurements WHERE Unit=?", Parameters: ["Teaspoons"], ConsistentRead: true, }, { Statement: "SELECT * FROM PepperMeasurements WHERE Unit=?", Parameters: ["Grams"], ConsistentRead: true, }, ], }); const response = await docClient.send(command); console.log(response); return response; };
Update a batch of items using PartiQL.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, BatchExecuteStatementCommand, } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const eggUpdates = [ ["duck", "fried"], ["chicken", "omelette"], ]; const command = new BatchExecuteStatementCommand({ Statements: eggUpdates.map((change) => ({ Statement: "UPDATE Eggs SET Style=? where Variety=?", Parameters: [change[1], change[0]], })), }); const response = await docClient.send(command); console.log(response); return response; };
Delete a batch of items using PartiQL.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, BatchExecuteStatementCommand, } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new BatchExecuteStatementCommand({ Statements: [ { Statement: "DELETE FROM Flavors where Name=?", Parameters: ["Grape"], }, { Statement: "DELETE FROM Flavors where Name=?", Parameters: ["Strawberry"], }, ], }); const response = await docClient.send(command); console.log(response); return response; };
-
For API details, see BatchExecuteStatement in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use BatchGetItem
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. This example uses the document client to simplify working with items in DynamoDB. For API details see BatchGet.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { BatchGetCommand, DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new BatchGetCommand({ // Each key in this object is the name of a table. This example refers // to a Books table. RequestItems: { Books: { // Each entry in Keys is an object that specifies a primary key. Keys: [ { Title: "How to AWS", }, { Title: "DynamoDB for DBAs", }, ], // Only return the "Title" and "PageCount" attributes. ProjectionExpression: "Title, PageCount", }, }, }); const response = await docClient.send(command); console.log(response.Responses.Books); return response; };
-
For more information, see AWS SDK for JavaScript Developer Guide.
-
For API details, see BatchGetItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use BatchWriteItem
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. This example uses the document client to simplify working with items in DynamoDB. For API details see BatchWrite.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { BatchWriteCommand, DynamoDBDocumentClient, } from "@aws-sdk/lib-dynamodb"; import { readFileSync } from "node:fs"; // These modules are local to our GitHub repository. We recommend cloning // the project from GitHub if you want to run this example. // For more information, see https://github.com/awsdocs/aws-doc-sdk-examples. import { dirnameFromMetaUrl } from "@aws-doc-sdk-examples/lib/utils/util-fs.js"; import { chunkArray } from "@aws-doc-sdk-examples/lib/utils/util-array.js"; const dirname = dirnameFromMetaUrl(import.meta.url); const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const file = readFileSync( `${dirname}../../../../../resources/sample_files/movies.json`, ); const movies = JSON.parse(file.toString()); // chunkArray is a local convenience function. It takes an array and returns // a generator function. The generator function yields every N items. const movieChunks = chunkArray(movies, 25); // For every chunk of 25 movies, make one BatchWrite request. for (const chunk of movieChunks) { const putRequests = chunk.map((movie) => ({ PutRequest: { Item: movie, }, })); const command = new BatchWriteCommand({ RequestItems: { // An existing table is required. A composite key of 'title' and 'year' is recommended // to account for duplicate titles. BatchWriteMoviesTable: putRequests, }, }); await docClient.send(command); } };
-
For API details, see BatchWriteItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use CreateTable
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. import { CreateTableCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb"; const client = new DynamoDBClient({}); export const main = async () => { const command = new CreateTableCommand({ TableName: "EspressoDrinks", // For more information about data types, // see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes and // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html#Programming.LowLevelAPI.DataTypeDescriptors AttributeDefinitions: [ { AttributeName: "DrinkName", AttributeType: "S", }, ], KeySchema: [ { AttributeName: "DrinkName", KeyType: "HASH", }, ], BillingMode: "PAY_PER_REQUEST", }); const response = await client.send(command); console.log(response); return response; };
-
For more information, see AWS SDK for JavaScript Developer Guide.
-
For API details, see CreateTable in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use DeleteItem
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. This example uses the document client to simplify working with items in DynamoDB. For API details see DeleteCommand.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, DeleteCommand } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new DeleteCommand({ TableName: "Sodas", Key: { Flavor: "Cola", }, }); const response = await docClient.send(command); console.log(response); return response; };
-
For more information, see AWS SDK for JavaScript Developer Guide.
-
For API details, see DeleteItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use DeleteTable
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. import { DeleteTableCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb"; const client = new DynamoDBClient({}); export const main = async () => { const command = new DeleteTableCommand({ TableName: "DecafCoffees", }); const response = await client.send(command); console.log(response); return response; };
-
For API details, see DeleteTable in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use DescribeTable
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. import { DescribeTableCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb"; const client = new DynamoDBClient({}); export const main = async () => { const command = new DescribeTableCommand({ TableName: "Pastries", }); const response = await client.send(command); console.log(`TABLE NAME: ${response.Table.TableName}`); console.log(`TABLE ITEM COUNT: ${response.Table.ItemCount}`); return response; };
-
For more information, see AWS SDK for JavaScript Developer Guide.
-
For API details, see DescribeTable in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use DescribeTimeToLive
.
- SDK for JavaScript (v3)
-
Describe TTL configuration on an existing DynamoDB table using AWS SDK for JavaScript.
import { DynamoDBClient, DescribeTimeToLiveCommand } from "@aws-sdk/client-dynamodb"; export const describeTTL = async (tableName, region) => { const client = new DynamoDBClient({ region: region, endpoint: `https://dynamodb.${region}.amazonaws.com` }); try { const ttlDescription = await client.send(new DescribeTimeToLiveCommand({ TableName: tableName })); if (ttlDescription.TimeToLiveDescription.TimeToLiveStatus === 'ENABLED') { console.log("TTL is enabled for table %s.", tableName); } else { console.log("TTL is not enabled for table %s.", tableName); } return ttlDescription; } catch (e) { console.error(`Error describing table: ${e}`); throw e; } } // Example usage (commented out for testing) // describeTTL('your-table-name', 'us-east-1');
-
For API details, see DescribeTimeToLive in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use ExecuteStatement
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. Create an item using PartiQL.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { ExecuteStatementCommand, DynamoDBDocumentClient, } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new ExecuteStatementCommand({ Statement: `INSERT INTO Flowers value {'Name':?}`, Parameters: ["Rose"], }); const response = await docClient.send(command); console.log(response); return response; };
Get an item using PartiQL.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { ExecuteStatementCommand, DynamoDBDocumentClient, } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new ExecuteStatementCommand({ Statement: "SELECT * FROM CloudTypes WHERE IsStorm=?", Parameters: [false], ConsistentRead: true, }); const response = await docClient.send(command); console.log(response); return response; };
Update an item using PartiQL.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { ExecuteStatementCommand, DynamoDBDocumentClient, } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new ExecuteStatementCommand({ Statement: "UPDATE EyeColors SET IsRecessive=? where Color=?", Parameters: [true, "blue"], }); const response = await docClient.send(command); console.log(response); return response; };
Delete an item using PartiQL.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { ExecuteStatementCommand, DynamoDBDocumentClient, } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new ExecuteStatementCommand({ Statement: "DELETE FROM PaintColors where Name=?", Parameters: ["Purple"], }); const response = await docClient.send(command); console.log(response); return response; };
-
For API details, see ExecuteStatement in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use GetItem
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. This example uses the document client to simplify working with items in DynamoDB. For API details see GetCommand.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, GetCommand } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new GetCommand({ TableName: "AngryAnimals", Key: { CommonName: "Shoebill", }, }); const response = await docClient.send(command); console.log(response); return response; };
-
For API details, see GetItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use ListTables
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. import { ListTablesCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb"; const client = new DynamoDBClient({}); export const main = async () => { const command = new ListTablesCommand({}); const response = await client.send(command); console.log(response); return response; };
-
For more information, see AWS SDK for JavaScript Developer Guide.
-
For API details, see ListTables in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use PutItem
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. This example uses the document client to simplify working with items in DynamoDB. For API details see PutCommand.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { PutCommand, DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new PutCommand({ TableName: "HappyAnimals", Item: { CommonName: "Shiba Inu", }, }); const response = await docClient.send(command); console.log(response); return response; };
-
For API details, see PutItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use Query
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. This example uses the document client to simplify working with items in DynamoDB. For API details see QueryCommand.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { QueryCommand, DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new QueryCommand({ TableName: "CoffeeCrop", KeyConditionExpression: "OriginCountry = :originCountry AND RoastDate > :roastDate", ExpressionAttributeValues: { ":originCountry": "Ethiopia", ":roastDate": "2023-05-01", }, ConsistentRead: true, }); const response = await docClient.send(command); console.log(response); return response; };
-
For more information, see AWS SDK for JavaScript Developer Guide.
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use Scan
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. This example uses the document client to simplify working with items in DynamoDB. For API details see ScanCommand.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, ScanCommand } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new ScanCommand({ ProjectionExpression: "#Name, Color, AvgLifeSpan", ExpressionAttributeNames: { "#Name": "Name" }, TableName: "Birds", }); const response = await docClient.send(command); for (const bird of response.Items) { console.log(`${bird.Name} - (${bird.Color}, ${bird.AvgLifeSpan})`); } return response; };
-
For API details, see Scan in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use UpdateItem
.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. This example uses the document client to simplify working with items in DynamoDB. For API details see UpdateCommand.
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, UpdateCommand } from "@aws-sdk/lib-dynamodb"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); export const main = async () => { const command = new UpdateCommand({ TableName: "Dogs", Key: { Breed: "Labrador", }, UpdateExpression: "set Color = :color", ExpressionAttributeValues: { ":color": "black", }, ReturnValues: "ALL_NEW", }); const response = await docClient.send(command); console.log(response); return response; };
-
For API details, see UpdateItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use UpdateTimeToLive
.
- SDK for JavaScript (v3)
-
Enable TTL on an existing DynamoDB table.
import { DynamoDBClient, UpdateTimeToLiveCommand } from "@aws-sdk/client-dynamodb"; export const enableTTL = async (tableName, ttlAttribute, region = 'us-east-1') => { const client = new DynamoDBClient({ region: region, endpoint: `https://dynamodb.${region}.amazonaws.com` }); const params = { TableName: tableName, TimeToLiveSpecification: { Enabled: true, AttributeName: ttlAttribute } }; try { const response = await client.send(new UpdateTimeToLiveCommand(params)); if (response.$metadata.httpStatusCode === 200) { console.log(`TTL enabled successfully for table ${tableName}, using attribute name ${ttlAttribute}.`); } else { console.log(`Failed to enable TTL for table ${tableName}, response object: ${response}`); } return response; } catch (e) { console.error(`Error enabling TTL: ${e}`); throw e; } }; // Example usage (commented out for testing) // enableTTL('ExampleTable', 'exampleTtlAttribute');
Disable TTL on an existing DynamoDB table.
import { DynamoDBClient, UpdateTimeToLiveCommand } from "@aws-sdk/client-dynamodb"; export const disableTTL = async (tableName, ttlAttribute, region = 'us-east-1') => { const client = new DynamoDBClient({ region: region, endpoint: `https://dynamodb.${region}.amazonaws.com` }); const params = { TableName: tableName, TimeToLiveSpecification: { Enabled: false, AttributeName: ttlAttribute } }; try { const response = await client.send(new UpdateTimeToLiveCommand(params)); if (response.$metadata.httpStatusCode === 200) { console.log(`TTL disabled successfully for table ${tableName}, using attribute name ${ttlAttribute}.`); } else { console.log(`Failed to disable TTL for table ${tableName}, response object: ${response}`); } return response; } catch (e) { console.error(`Error disabling TTL: ${e}`); throw e; } }; // Example usage (commented out for testing) // disableTTL('ExampleTable', 'exampleTtlAttribute');
-
For API details, see UpdateTimeToLive in AWS SDK for JavaScript API Reference.
-
Scenarios
The following code example shows how to build an application that submits data to an Amazon DynamoDB table and notifies you when a user updates the table.
- SDK for JavaScript (v3)
-
This example shows how to build an app that enables users to submit data to an Amazon DynamoDB table, and send a text message to the administrator using Amazon Simple Notification Service (Amazon SNS).
For complete source code and instructions on how to set up and run, see the full example on GitHub
. This example is also available in the AWS SDK for JavaScript v3 developer guide.
Services used in this example
DynamoDB
Amazon SNS
The following code example shows how to compare multiple values with a single attribute in DynamoDB.
Use the IN operator to compare multiple values with a single attribute.
Compare the IN operator with multiple OR conditions.
Understand the performance and expression complexity benefits of using IN.
- SDK for JavaScript (v3)
-
Compare multiple values with a single attribute using AWS SDK for JavaScript.
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb"); const { DynamoDBDocumentClient, ScanCommand, QueryCommand } = require("@aws-sdk/lib-dynamodb"); /** * Query or scan a DynamoDB table to find items where an attribute matches any value from a list. * * This function demonstrates the use of the IN operator to compare a single attribute * against multiple possible values, which is more efficient than using multiple OR conditions. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} attributeName - The name of the attribute to compare against the values list * @param {Array} valuesList - List of values to compare the attribute against * @param {string} [partitionKeyName] - Optional name of the partition key attribute for query operations * @param {string} [partitionKeyValue] - Optional value of the partition key to query * @returns {Promise<Object>} - The response from DynamoDB containing the matching items */ async function compareMultipleValues( config, tableName, attributeName, valuesList, partitionKeyName, partitionKeyValue ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Create the filter expression using the IN operator const filterExpression = `${attributeName} IN (${valuesList.map((_, index) => `:val${index}`).join(', ')})`; // Create expression attribute values for the values list const expressionAttributeValues = valuesList.reduce((acc, val, index) => { acc[`:val${index}`] = val; return acc; }, {}); // If partition key is provided, perform a query operation if (partitionKeyName && partitionKeyValue) { const keyCondition = `${partitionKeyName} = :partitionKey`; expressionAttributeValues[':partitionKey'] = partitionKeyValue; // Initialize array to collect all items let allItems = []; let lastEvaluatedKey; // Use pagination to get all results do { const params = { TableName: tableName, KeyConditionExpression: keyCondition, FilterExpression: filterExpression, ExpressionAttributeValues: expressionAttributeValues }; // Add ExclusiveStartKey if we have a lastEvaluatedKey from a previous query if (lastEvaluatedKey) { params.ExclusiveStartKey = lastEvaluatedKey; } const response = await docClient.send(new QueryCommand(params)); // Add the items from this page to our collection if (response.Items && response.Items.length > 0) { allItems = [...allItems, ...response.Items]; } // Get the key for the next page of results lastEvaluatedKey = response.LastEvaluatedKey; } while (lastEvaluatedKey); // Return the complete result return { Items: allItems, Count: allItems.length }; } else { // Otherwise, perform a scan operation // Initialize array to collect all items let allItems = []; let lastEvaluatedKey; // Use pagination to get all results do { const params = { TableName: tableName, FilterExpression: filterExpression, ExpressionAttributeValues: expressionAttributeValues }; // Add ExclusiveStartKey if we have a lastEvaluatedKey from a previous scan if (lastEvaluatedKey) { params.ExclusiveStartKey = lastEvaluatedKey; } const response = await docClient.send(new ScanCommand(params)); // Add the items from this page to our collection if (response.Items && response.Items.length > 0) { allItems = [...allItems, ...response.Items]; } // Get the key for the next page of results lastEvaluatedKey = response.LastEvaluatedKey; } while (lastEvaluatedKey); // Return the complete result return { Items: allItems, Count: allItems.length }; } } /** * Alternative implementation using multiple OR conditions instead of the IN operator. * * This function is provided for comparison to show why using the IN operator is preferable. * With many values, this approach becomes verbose and less efficient. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} attributeName - The name of the attribute to compare against the values list * @param {Array} valuesList - List of values to compare the attribute against * @param {string} [partitionKeyName] - Optional name of the partition key attribute for query operations * @param {string} [partitionKeyValue] - Optional value of the partition key to query * @returns {Promise<Object>} - The response from DynamoDB containing the matching items */ async function compareWithOrConditions( config, tableName, attributeName, valuesList, partitionKeyName, partitionKeyValue ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // If no values provided, return empty result if (!valuesList || valuesList.length === 0) { return { Items: [], Count: 0 }; } // Create the filter expression using multiple OR conditions const filterConditions = valuesList.map((_, index) => `${attributeName} = :val${index}`); const filterExpression = filterConditions.join(' OR '); // Create expression attribute values for the values list const expressionAttributeValues = valuesList.reduce((acc, val, index) => { acc[`:val${index}`] = val; return acc; }, {}); // If partition key is provided, perform a query operation if (partitionKeyName && partitionKeyValue) { const keyCondition = `${partitionKeyName} = :partitionKey`; expressionAttributeValues[':partitionKey'] = partitionKeyValue; // Initialize array to collect all items let allItems = []; let lastEvaluatedKey; // Use pagination to get all results do { const params = { TableName: tableName, KeyConditionExpression: keyCondition, FilterExpression: filterExpression, ExpressionAttributeValues: expressionAttributeValues }; // Add ExclusiveStartKey if we have a lastEvaluatedKey from a previous query if (lastEvaluatedKey) { params.ExclusiveStartKey = lastEvaluatedKey; } const response = await docClient.send(new QueryCommand(params)); // Add the items from this page to our collection if (response.Items && response.Items.length > 0) { allItems = [...allItems, ...response.Items]; } // Get the key for the next page of results lastEvaluatedKey = response.LastEvaluatedKey; } while (lastEvaluatedKey); // Return the complete result return { Items: allItems, Count: allItems.length }; } else { // Otherwise, perform a scan operation // Initialize array to collect all items let allItems = []; let lastEvaluatedKey; // Use pagination to get all results do { const params = { TableName: tableName, FilterExpression: filterExpression, ExpressionAttributeValues: expressionAttributeValues }; // Add ExclusiveStartKey if we have a lastEvaluatedKey from a previous scan if (lastEvaluatedKey) { params.ExclusiveStartKey = lastEvaluatedKey; } const response = await docClient.send(new ScanCommand(params)); // Add the items from this page to our collection if (response.Items && response.Items.length > 0) { allItems = [...allItems, ...response.Items]; } // Get the key for the next page of results lastEvaluatedKey = response.LastEvaluatedKey; } while (lastEvaluatedKey); // Return the complete result return { Items: allItems, Count: allItems.length }; } }
Example usage of comparing multiple values with AWS SDK for JavaScript.
/** * Example of how to use the compareMultipleValues function. */ async function exampleUsage() { // Example parameters const config = { region: "us-west-2" }; const tableName = "Products"; const attributeName = "Category"; const valuesList = ["Electronics", "Computers", "Accessories"]; console.log(`Searching for products in any of these categories: ${valuesList.join(', ')}`); try { // Using the IN operator (recommended approach) console.log("\nApproach 1: Using the IN operator"); const response = await compareMultipleValues( config, tableName, attributeName, valuesList ); console.log(`Found ${response.Count} products in the specified categories`); // Using multiple OR conditions (alternative approach) console.log("\nApproach 2: Using multiple OR conditions"); const response2 = await compareWithOrConditions( config, tableName, attributeName, valuesList ); console.log(`Found ${response2.Count} products in the specified categories`); // Example with a query operation console.log("\nQuerying a specific manufacturer's products in multiple categories"); const partitionKeyName = "Manufacturer"; const partitionKeyValue = "Acme"; const response3 = await compareMultipleValues( config, tableName, attributeName, valuesList, partitionKeyName, partitionKeyValue ); console.log(`Found ${response3.Count} Acme products in the specified categories`); // Explain the benefits of using the IN operator console.log("\nBenefits of using the IN operator:"); console.log("1. More concise expression compared to multiple OR conditions"); console.log("2. Better readability and maintainability"); console.log("3. Potentially better performance with large value lists"); console.log("4. Simpler code that's less prone to errors"); console.log("5. Easier to modify when adding or removing values"); } catch (error) { console.error("Error:", error); } }
The following code example shows how to conditionally update an item's TTL.
- SDK for JavaScript (v3)
-
Update TTL on on an existing DynamoDB Item in a table, with a condition.
import { DynamoDBClient, UpdateItemCommand } from "@aws-sdk/client-dynamodb"; import { marshall, unmarshall } from "@aws-sdk/util-dynamodb"; export const updateItemConditional = async (tableName, partitionKey, sortKey, region = 'us-east-1', newAttribute = 'default-value') => { const client = new DynamoDBClient({ region: region, endpoint: `https://dynamodb.${region}.amazonaws.com` }); const currentTime = Math.floor(Date.now() / 1000); const params = { TableName: tableName, Key: marshall({ artist: partitionKey, album: sortKey }), UpdateExpression: "SET newAttribute = :newAttribute", ConditionExpression: "expireAt > :expiration", ExpressionAttributeValues: marshall({ ':newAttribute': newAttribute, ':expiration': currentTime }), ReturnValues: "ALL_NEW" }; try { const response = await client.send(new UpdateItemCommand(params)); const responseData = unmarshall(response.Attributes); console.log("Item updated successfully: ", responseData); return responseData; } catch (error) { if (error.name === "ConditionalCheckFailedException") { console.log("Condition check failed: Item's 'expireAt' is expired."); } else { console.error("Error updating item: ", error); } throw error; } }; // Example usage (commented out for testing) // updateItemConditional('your-table-name', 'your-partition-key-value', 'your-sort-key-value');
-
For API details, see UpdateItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to count expression operators in DynamoDB.
Understand DynamoDB's 300 operator limit.
Count operators in complex expressions.
Optimize expressions to stay within limits.
- SDK for JavaScript (v3)
-
Demonstrate expression operator counting using AWS SDK for JavaScript.
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb"); const { DynamoDBDocumentClient, UpdateCommand, QueryCommand } = require("@aws-sdk/lib-dynamodb"); /** * Create a complex filter expression with a specified number of conditions. * * This function demonstrates how to generate a complex expression with * a specific number of operators to test the 300 operator limit. * * @param {number} conditionsCount - Number of conditions to include * @param {boolean} useAnd - Whether to use AND (true) or OR (false) between conditions * @returns {Object} - Object containing the filter expression and attribute values */ function createComplexFilterExpression(conditionsCount, useAnd = true) { // Initialize the expression parts and attribute values const conditions = []; const expressionAttributeValues = {}; // Generate the specified number of conditions for (let i = 0; i < conditionsCount; i++) { // Alternate between different comparison operators for variety let condition; const valueKey = `:val${i}`; switch (i % 5) { case 0: condition = `attribute${i} = ${valueKey}`; expressionAttributeValues[valueKey] = `value${i}`; break; case 1: condition = `attribute${i} > ${valueKey}`; expressionAttributeValues[valueKey] = i; break; case 2: condition = `attribute${i} < ${valueKey}`; expressionAttributeValues[valueKey] = i * 10; break; case 3: condition = `contains(attribute${i}, ${valueKey})`; expressionAttributeValues[valueKey] = `substring${i}`; break; case 4: condition = `attribute_exists(attribute${i})`; break; } conditions.push(condition); } // Join the conditions with AND or OR const operator = useAnd ? " AND " : " OR "; const filterExpression = conditions.join(operator); // Calculate the operator count // Each condition has 1 operator (=, >, <, contains, attribute_exists) // Each AND or OR between conditions is 1 operator const operatorCount = conditionsCount + (conditionsCount > 0 ? conditionsCount - 1 : 0); return { filterExpression, expressionAttributeValues, operatorCount }; } /** * Create a complex update expression with a specified number of operations. * * This function demonstrates how to generate a complex update expression with * a specific number of operators to test the 300 operator limit. * * @param {number} operationsCount - Number of operations to include * @returns {Object} - Object containing the update expression and attribute values */ function createComplexUpdateExpression(operationsCount) { // Initialize the expression parts and attribute values const setOperations = []; const expressionAttributeValues = {}; // Generate the specified number of SET operations for (let i = 0; i < operationsCount; i++) { // Alternate between different types of SET operations let operation; const valueKey = `:val${i}`; switch (i % 3) { case 0: // Simple assignment (1 operator: =) operation = `attribute${i} = ${valueKey}`; expressionAttributeValues[valueKey] = `value${i}`; break; case 1: // Addition (2 operators: = and +) operation = `attribute${i} = attribute${i} + ${valueKey}`; expressionAttributeValues[valueKey] = i; break; case 2: // Conditional assignment with if_not_exists (2 operators: = and if_not_exists) operation = `attribute${i} = if_not_exists(attribute${i}, ${valueKey})`; expressionAttributeValues[valueKey] = i * 10; break; } setOperations.push(operation); } // Create the update expression const updateExpression = `SET ${setOperations.join(", ")}`; // Calculate the operator count // Each operation has 1-2 operators as noted above let operatorCount = 0; for (let i = 0; i < operationsCount; i++) { operatorCount += (i % 3 === 0) ? 1 : 2; } return { updateExpression, expressionAttributeValues, operatorCount }; } /** * Test the operator limit by attempting an operation with a complex expression. * * This function demonstrates what happens when an expression approaches or * exceeds the 300 operator limit. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {number} operatorCount - Target number of operators to include * @returns {Promise<Object>} - Result of the operation attempt */ async function testOperatorLimit( config, tableName, key, operatorCount ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Create a complex update expression with the specified operator count const { updateExpression, expressionAttributeValues, operatorCount: actualCount } = createComplexUpdateExpression(Math.ceil(operatorCount / 1.5)); // Adjust to get close to target count console.log(`Generated update expression with approximately ${actualCount} operators`); // Define the update parameters const params = { TableName: tableName, Key: key, UpdateExpression: updateExpression, ExpressionAttributeValues: expressionAttributeValues, ReturnValues: "UPDATED_NEW" }; try { // Attempt the update operation const response = await docClient.send(new UpdateCommand(params)); return { success: true, message: `Operation succeeded with ${actualCount} operators`, data: response }; } catch (error) { // Check if the error is due to exceeding the operator limit if (error.name === "ValidationException" && error.message.includes("too many operators")) { return { success: false, message: `Operation failed: ${error.message}`, operatorCount: actualCount }; } // Return other errors return { success: false, message: `Operation failed: ${error.message}`, error }; } } /** * Break down a complex expression into multiple simpler operations. * * This function demonstrates how to handle expressions that would exceed * the 300 operator limit by breaking them into multiple operations. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {number} totalOperations - Total number of operations to perform * @returns {Promise<Object>} - Result of the operations */ async function breakDownComplexExpression( config, tableName, key, totalOperations ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Calculate how many operations we can safely include in each batch // Using 150 as a conservative limit (well below 300) const operationsPerBatch = 100; const batchCount = Math.ceil(totalOperations / operationsPerBatch); console.log(`Breaking down ${totalOperations} operations into ${batchCount} batches`); const results = []; // Process each batch for (let batch = 0; batch < batchCount; batch++) { // Calculate the operations for this batch const batchStart = batch * operationsPerBatch; const batchEnd = Math.min(batchStart + operationsPerBatch, totalOperations); const batchSize = batchEnd - batchStart; console.log(`Processing batch ${batch + 1}/${batchCount} with ${batchSize} operations`); // Create an update expression for this batch const { updateExpression, expressionAttributeValues, operatorCount } = createComplexUpdateExpression(batchSize); // Define the update parameters const params = { TableName: tableName, Key: key, UpdateExpression: updateExpression, ExpressionAttributeValues: expressionAttributeValues, ReturnValues: "UPDATED_NEW" }; try { // Perform the update operation for this batch const response = await docClient.send(new UpdateCommand(params)); results.push({ batch: batch + 1, success: true, operatorCount, attributes: response.Attributes }); } catch (error) { results.push({ batch: batch + 1, success: false, operatorCount, error: error.message }); // Stop processing if an error occurs break; } } return { totalBatches: batchCount, results }; } /** * Count operators in a DynamoDB expression based on the rules in the documentation. * * This function demonstrates how operators are counted according to the * DynamoDB documentation. * * @param {string} expression - The DynamoDB expression to analyze * @returns {Object} - Breakdown of operator counts */ function countOperatorsInExpression(expression) { // Initialize counters for different operator types const counts = { comparisonOperators: 0, logicalOperators: 0, functions: 0, arithmeticOperators: 0, specialOperators: 0, total: 0 }; // Count comparison operators (=, <>, <, <=, >, >=) const comparisonRegex = /[^<>]=[^=]|<>|<=|>=|[^<]>[^=]|[^>]<[^=]/g; const comparisonMatches = expression.match(comparisonRegex) || []; counts.comparisonOperators = comparisonMatches.length; // Count logical operators (AND, OR, NOT) const andMatches = expression.match(/\bAND\b/g) || []; const orMatches = expression.match(/\bOR\b/g) || []; const notMatches = expression.match(/\bNOT\b/g) || []; counts.logicalOperators = andMatches.length + orMatches.length + notMatches.length; // Count functions (attribute_exists, attribute_not_exists, attribute_type, begins_with, contains, size) const functionRegex = /\b(attribute_exists|attribute_not_exists|attribute_type|begins_with|contains|size|if_not_exists)\(/g; const functionMatches = expression.match(functionRegex) || []; counts.functions = functionMatches.length; // Count arithmetic operators (+ and -) const arithmeticMatches = expression.match(/[a-zA-Z0-9_)\]]\s*[\+\-]\s*[a-zA-Z0-9_(:]/g) || []; counts.arithmeticOperators = arithmeticMatches.length; // Count special operators (BETWEEN, IN) const betweenMatches = expression.match(/\bBETWEEN\b/g) || []; const inMatches = expression.match(/\bIN\b/g) || []; counts.specialOperators = betweenMatches.length + inMatches.length; // Add extra operators for BETWEEN (each BETWEEN includes an AND) counts.logicalOperators += betweenMatches.length; // Calculate total counts.total = counts.comparisonOperators + counts.logicalOperators + counts.functions + counts.arithmeticOperators + counts.specialOperators; return counts; }
Example usage of expression operator counting with AWS SDK for JavaScript.
/** * Example of how to work with expression operator counting. */ async function exampleUsage() { // Example parameters const config = { region: "us-west-2" }; const tableName = "Products"; const key = { ProductId: "P12345" }; console.log("Demonstrating DynamoDB expression operator counting and the 300 operator limit"); try { // Example 1: Analyze a simple expression console.log("\nExample 1: Analyzing a simple expression"); const simpleExpression = "Price = :price AND Rating > :rating AND Category IN (:cat1, :cat2, :cat3)"; const simpleCount = countOperatorsInExpression(simpleExpression); console.log(`Expression: ${simpleExpression}`); console.log("Operator count breakdown:"); console.log(`- Comparison operators: ${simpleCount.comparisonOperators}`); console.log(`- Logical operators: ${simpleCount.logicalOperators}`); console.log(`- Functions: ${simpleCount.functions}`); console.log(`- Arithmetic operators: ${simpleCount.arithmeticOperators}`); console.log(`- Special operators: ${simpleCount.specialOperators}`); console.log(`- Total operators: ${simpleCount.total}`); // Example 2: Analyze a complex expression console.log("\nExample 2: Analyzing a complex expression"); const complexExpression = "(attribute_exists(Category) AND Size BETWEEN :min AND :max) OR " + "(Price > :price AND contains(Description, :keyword) AND " + "(Rating >= :minRating OR Reviews > :minReviews))"; const complexCount = countOperatorsInExpression(complexExpression); console.log(`Expression: ${complexExpression}`); console.log("Operator count breakdown:"); console.log(`- Comparison operators: ${complexCount.comparisonOperators}`); console.log(`- Logical operators: ${complexCount.logicalOperators}`); console.log(`- Functions: ${complexCount.functions}`); console.log(`- Arithmetic operators: ${complexCount.arithmeticOperators}`); console.log(`- Special operators: ${complexCount.specialOperators}`); console.log(`- Total operators: ${complexCount.total}`); // Example 3: Test approaching the operator limit console.log("\nExample 3: Testing an expression approaching the operator limit"); const approachingLimit = await testOperatorLimit(config, tableName, key, 290); console.log(approachingLimit.message); // Example 4: Test exceeding the operator limit console.log("\nExample 4: Testing an expression exceeding the operator limit"); const exceedingLimit = await testOperatorLimit(config, tableName, key, 310); console.log(exceedingLimit.message); // Example 5: Breaking down a complex expression console.log("\nExample 5: Breaking down a complex expression into multiple operations"); const breakdownResult = await breakDownComplexExpression(config, tableName, key, 500); console.log(`Processed ${breakdownResult.results.length} of ${breakdownResult.totalBatches} batches`); // Explain the operator counting rules console.log("\nKey points about DynamoDB expression operator counting:"); console.log("1. The maximum number of operators in any expression is 300"); console.log("2. Each comparison operator (=, <>, <, <=, >, >=) counts as 1 operator"); console.log("3. Each logical operator (AND, OR, NOT) counts as 1 operator"); console.log("4. Each function call (attribute_exists, contains, etc.) counts as 1 operator"); console.log("5. Each arithmetic operator (+ or -) counts as 1 operator"); console.log("6. BETWEEN counts as 2 operators (BETWEEN itself and the AND within it)"); console.log("7. IN counts as 1 operator regardless of the number of values"); console.log("8. Parentheses for grouping and attribute paths don't count as operators"); console.log("9. When you exceed the limit, the error always reports '301 operators'"); console.log("10. For complex operations, break them into multiple smaller operations"); } catch (error) { console.error("Error:", error); } }
-
For API details, see UpdateItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to create a serverless application that lets users manage photos using labels.
- SDK for JavaScript (v3)
-
Shows how to develop a photo asset management application that detects labels in images using Amazon Rekognition and stores them for later retrieval.
For complete source code and instructions on how to set up and run, see the full example on GitHub
. For a deep dive into the origin of this example see the post on AWS Community
. Services used in this example
API Gateway
DynamoDB
Lambda
Amazon Rekognition
Amazon S3
Amazon SNS
The following code example shows how to create a table with warm throughput enabled.
- SDK for JavaScript (v3)
-
Create DynamoDB table with warm throughput setting using AWS SDK for JavaScript.
import { DynamoDBClient, CreateTableCommand } from "@aws-sdk/client-dynamodb"; export async function createDynamoDBTableWithWarmThroughput( tableName, partitionKey, sortKey, miscKeyAttr, nonKeyAttr, tableProvisionedReadUnits, tableProvisionedWriteUnits, tableWarmReads, tableWarmWrites, indexName, indexProvisionedReadUnits, indexProvisionedWriteUnits, indexWarmReads, indexWarmWrites, region = "us-east-1" ) { try { const ddbClient = new DynamoDBClient({ region: region }); const command = new CreateTableCommand({ TableName: tableName, AttributeDefinitions: [ { AttributeName: partitionKey, AttributeType: "S" }, { AttributeName: sortKey, AttributeType: "S" }, { AttributeName: miscKeyAttr, AttributeType: "N" }, ], KeySchema: [ { AttributeName: partitionKey, KeyType: "HASH" }, { AttributeName: sortKey, KeyType: "RANGE" }, ], ProvisionedThroughput: { ReadCapacityUnits: tableProvisionedReadUnits, WriteCapacityUnits: tableProvisionedWriteUnits, }, WarmThroughput: { ReadUnitsPerSecond: tableWarmReads, WriteUnitsPerSecond: tableWarmWrites, }, GlobalSecondaryIndexes: [ { IndexName: indexName, KeySchema: [ { AttributeName: sortKey, KeyType: "HASH" }, { AttributeName: miscKeyAttr, KeyType: "RANGE" }, ], Projection: { ProjectionType: "INCLUDE", NonKeyAttributes: [nonKeyAttr], }, ProvisionedThroughput: { ReadCapacityUnits: indexProvisionedReadUnits, WriteCapacityUnits: indexProvisionedWriteUnits, }, WarmThroughput: { ReadUnitsPerSecond: indexWarmReads, WriteUnitsPerSecond: indexWarmWrites, }, }, ], }); const response = await ddbClient.send(command); console.log(response); return response; } catch (error) { console.error(`Error creating table: ${error}`); throw error; } } // Example usage (commented out for testing) /* createDynamoDBTableWithWarmThroughput( 'example-table', 'pk', 'sk', 'gsiKey', 'data', 10, 10, 5, 5, 'example-index', 5, 5, 2, 2 ); */
-
For API details, see CreateTable in AWS SDK for JavaScript API Reference.
-
The following code example shows how to create an item with TTL.
- SDK for JavaScript (v3)
-
import { DynamoDBClient, PutItemCommand } from "@aws-sdk/client-dynamodb"; export function createDynamoDBItem(table_name, region, partition_key, sort_key) { const client = new DynamoDBClient({ region: region, endpoint: `https://dynamodb.${region}.amazonaws.com` }); // Get the current time in epoch second format const current_time = Math.floor(new Date().getTime() / 1000); // Calculate the expireAt time (90 days from now) in epoch second format const expire_at = Math.floor((new Date().getTime() + 90 * 24 * 60 * 60 * 1000) / 1000); // Create DynamoDB item const item = { 'partitionKey': {'S': partition_key}, 'sortKey': {'S': sort_key}, 'createdAt': {'N': current_time.toString()}, 'expireAt': {'N': expire_at.toString()} }; const putItemCommand = new PutItemCommand({ TableName: table_name, Item: item, ProvisionedThroughput: { ReadCapacityUnits: 1, WriteCapacityUnits: 1, }, }); client.send(putItemCommand, function(err, data) { if (err) { console.log("Exception encountered when creating item %s, here's what happened: ", data, err); throw err; } else { console.log("Item created successfully: %s.", data); return data; } }); } // Example usage (commented out for testing) // createDynamoDBItem('your-table-name', 'us-east-1', 'your-partition-key-value', 'your-sort-key-value');
-
For API details, see PutItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to delete data using PartiQL DELETE statements.
- SDK for JavaScript (v3)
-
Delete items from a DynamoDB table using PartiQL DELETE statements with AWS SDK for JavaScript.
/** * This example demonstrates how to delete items from a DynamoDB table using PartiQL. * It shows different ways to delete documents with various index types. */ import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, ExecuteStatementCommand, BatchExecuteStatementCommand, } from "@aws-sdk/lib-dynamodb"; /** * Delete a single item by its partition key using PartiQL. * * @param tableName - The name of the DynamoDB table * @param partitionKeyName - The name of the partition key attribute * @param partitionKeyValue - The value of the partition key * @returns The response from the ExecuteStatementCommand */ export const deleteItemByPartitionKey = async ( tableName: string, partitionKeyName: string, partitionKeyValue: string | number ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `DELETE FROM "${tableName}" WHERE ${partitionKeyName} = ?`, Parameters: [partitionKeyValue], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Item deleted successfully"); return data; } catch (err) { console.error("Error deleting item:", err); throw err; } }; /** * Delete an item by its composite key (partition key + sort key) using PartiQL. * * @param tableName - The name of the DynamoDB table * @param partitionKeyName - The name of the partition key attribute * @param partitionKeyValue - The value of the partition key * @param sortKeyName - The name of the sort key attribute * @param sortKeyValue - The value of the sort key * @returns The response from the ExecuteStatementCommand */ export const deleteItemByCompositeKey = async ( tableName: string, partitionKeyName: string, partitionKeyValue: string | number, sortKeyName: string, sortKeyValue: string | number ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `DELETE FROM "${tableName}" WHERE ${partitionKeyName} = ? AND ${sortKeyName} = ?`, Parameters: [partitionKeyValue, sortKeyValue], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Item deleted successfully"); return data; } catch (err) { console.error("Error deleting item:", err); throw err; } }; /** * Delete an item with a condition to ensure the delete only happens if a condition is met. * * @param tableName - The name of the DynamoDB table * @param partitionKeyName - The name of the partition key attribute * @param partitionKeyValue - The value of the partition key * @param conditionAttribute - The attribute to check in the condition * @param conditionValue - The value to compare against in the condition * @returns The response from the ExecuteStatementCommand */ export const deleteItemWithCondition = async ( tableName: string, partitionKeyName: string, partitionKeyValue: string | number, conditionAttribute: string, conditionValue: any ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `DELETE FROM "${tableName}" WHERE ${partitionKeyName} = ? AND ${conditionAttribute} = ?`, Parameters: [partitionKeyValue, conditionValue], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Item deleted with condition successfully"); return data; } catch (err) { console.error("Error deleting item with condition:", err); throw err; } }; /** * Batch delete multiple items using PartiQL. * * @param tableName - The name of the DynamoDB table * @param keys - Array of objects containing key information * @returns The response from the BatchExecuteStatementCommand */ export const batchDeleteItems = async ( tableName: string, keys: Array<{ partitionKeyName: string; partitionKeyValue: string | number; sortKeyName?: string; sortKeyValue?: string | number; }> ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); // Create statements for each delete const statements = keys.map((key) => { if (key.sortKeyName && key.sortKeyValue !== undefined) { return { Statement: `DELETE FROM "${tableName}" WHERE ${key.partitionKeyName} = ? AND ${key.sortKeyName} = ?`, Parameters: [key.partitionKeyValue, key.sortKeyValue], }; } else { return { Statement: `DELETE FROM "${tableName}" WHERE ${key.partitionKeyName} = ?`, Parameters: [key.partitionKeyValue], }; } }); const params = { Statements: statements, }; try { const data = await docClient.send(new BatchExecuteStatementCommand(params)); console.log("Items batch deleted successfully"); return data; } catch (err) { console.error("Error batch deleting items:", err); throw err; } }; /** * Delete multiple items that match a filter condition. * Note: This performs a scan operation which can be expensive on large tables. * * @param tableName - The name of the DynamoDB table * @param filterAttribute - The attribute to filter on * @param filterValue - The value to filter by * @returns The response from the ExecuteStatementCommand */ export const deleteItemsByFilter = async ( tableName: string, filterAttribute: string, filterValue: any ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `DELETE FROM "${tableName}" WHERE ${filterAttribute} = ?`, Parameters: [filterValue], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Items deleted by filter successfully"); return data; } catch (err) { console.error("Error deleting items by filter:", err); throw err; } }; /** * Example usage showing how to delete items with different index types */ export const deleteExamples = async () => { // Delete an item by partition key (simple primary key) await deleteItemByPartitionKey("UsersTable", "userId", "user123"); // Delete an item by composite key (partition key + sort key) await deleteItemByCompositeKey( "OrdersTable", "orderId", "order456", "productId", "prod789" ); // Delete with a condition await deleteItemWithCondition( "UsersTable", "userId", "user789", "userStatus", "inactive" ); // Batch delete multiple items await batchDeleteItems("UsersTable", [ { partitionKeyName: "userId", partitionKeyValue: "user234" }, { partitionKeyName: "userId", partitionKeyValue: "user345" }, ]); // Batch delete items with composite keys await batchDeleteItems("OrdersTable", [ { partitionKeyName: "orderId", partitionKeyValue: "order567", sortKeyName: "productId", sortKeyValue: "prod123", }, { partitionKeyName: "orderId", partitionKeyValue: "order678", sortKeyName: "productId", sortKeyValue: "prod456", }, ]); // Delete items by filter (use with caution) await deleteItemsByFilter("UsersTable", "userStatus", "deleted"); };
-
For API details, see the following topics in AWS SDK for JavaScript API Reference.
-
The following code example shows how to insert data using PartiQL INSERT statements.
- SDK for JavaScript (v3)
-
Insert items into a DynamoDB table using PartiQL INSERT statements with AWS SDK for JavaScript.
/** * This example demonstrates how to insert items into a DynamoDB table using PartiQL. * It shows different ways to insert documents with various index types. */ import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, ExecuteStatementCommand, BatchExecuteStatementCommand, } from "@aws-sdk/lib-dynamodb"; /** * Insert a single item into a DynamoDB table using PartiQL. * * @param tableName - The name of the DynamoDB table * @param item - The item to insert * @returns The response from the ExecuteStatementCommand */ export const insertItem = async (tableName: string, item: Record<string, any>) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); // Convert the item to a string representation for PartiQL const itemString = JSON.stringify(item).replace(/"([^"]+)":/g, '$1:'); const params = { Statement: `INSERT INTO "${tableName}" VALUE ${itemString}`, }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Item inserted successfully"); return data; } catch (err) { console.error("Error inserting item:", err); throw err; } }; /** * Insert multiple items into a DynamoDB table using PartiQL batch operation. * This is more efficient than inserting items one by one. * * @param tableName - The name of the DynamoDB table * @param items - Array of items to insert * @returns The response from the BatchExecuteStatementCommand */ export const batchInsertItems = async (tableName: string, items: Record<string, any>[]) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); // Create statements for each item const statements = items.map((item) => { const itemString = JSON.stringify(item).replace(/"([^"]+)":/g, '$1:'); return { Statement: `INSERT INTO "${tableName}" VALUE ${itemString}`, }; }); const params = { Statements: statements, }; try { const data = await docClient.send(new BatchExecuteStatementCommand(params)); console.log("Items inserted successfully"); return data; } catch (err) { console.error("Error batch inserting items:", err); throw err; } }; /** * Insert an item with a condition to prevent overwriting existing items. * This is useful for ensuring you don't accidentally overwrite data. * * @param tableName - The name of the DynamoDB table * @param item - The item to insert * @param partitionKeyName - The name of the partition key attribute * @returns The response from the ExecuteStatementCommand */ export const insertItemWithCondition = async ( tableName: string, item: Record<string, any>, partitionKeyName: string ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const itemString = JSON.stringify(item).replace(/"([^"]+)":/g, '$1:'); const partitionKeyValue = JSON.stringify(item[partitionKeyName]); const params = { Statement: `INSERT INTO "${tableName}" VALUE ${itemString} WHERE attribute_not_exists(${partitionKeyName})`, Parameters: [{ S: partitionKeyValue }], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Item inserted with condition successfully"); return data; } catch (err) { console.error("Error inserting item with condition:", err); throw err; } }; /** * Example usage showing how to insert items with different index types */ export const insertExamples = async () => { // Example table with a simple primary key (just partition key) const simpleKeyItem = { userId: "user123", name: "John Doe", email: "[email protected]", }; await insertItem("UsersTable", simpleKeyItem); // Example table with composite key (partition key + sort key) const compositeKeyItem = { orderId: "order456", productId: "prod789", quantity: 2, price: 29.99, }; await insertItem("OrdersTable", compositeKeyItem); // Example with Global Secondary Index (GSI) // The GSI might be on the email attribute const gsiItem = { userId: "user789", email: "[email protected]", name: "Jane Smith", userType: "premium", // This could be part of a GSI }; await insertItem("UsersTable", gsiItem); // Example with Local Secondary Index (LSI) // LSI uses the same partition key but different sort key const lsiItem = { orderId: "order567", // Partition key productId: "prod123", // Sort key for the table orderDate: "2023-11-15", // Potential sort key for an LSI quantity: 1, price: 19.99, }; await insertItem("OrdersTable", lsiItem); // Batch insert example with multiple items const batchItems = [ { userId: "user234", name: "Alice Johnson", email: "[email protected]", }, { userId: "user345", name: "Bob Williams", email: "[email protected]", }, ]; await batchInsertItems("UsersTable", batchItems); };
-
For API details, see the following topics in AWS SDK for JavaScript API Reference.
-
The following code example shows how to invoke an AWS Lambda function from a browser.
- SDK for JavaScript (v3)
-
You can create a browser-based application that uses an AWS Lambda function to update an Amazon DynamoDB table with user selections. This app uses AWS SDK for JavaScript v3.
For complete source code and instructions on how to set up and run, see the full example on GitHub
. Services used in this example
DynamoDB
Lambda
The following code example shows how to perform advanced query operations in DynamoDB.
Query tables using various filtering and condition techniques.
Implement pagination for large result sets.
Use Global Secondary Indexes for alternate access patterns.
Apply consistency controls based on application requirements.
- SDK for JavaScript (v3)
-
Query with strongly consistent reads using AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table with configurable read consistency * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} partitionKeyName - The name of the partition key * @param {string} partitionKeyValue - The value of the partition key * @param {boolean} useConsistentRead - Whether to use strongly consistent reads * @returns {Promise<Object>} - The query response */ async function queryWithConsistentRead( config, tableName, partitionKeyName, partitionKeyValue, useConsistentRead = false ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Construct the query input const input = { TableName: tableName, KeyConditionExpression: "#pk = :pkValue", ExpressionAttributeNames: { "#pk": partitionKeyName }, ExpressionAttributeValues: { ":pkValue": { S: partitionKeyValue } }, ConsistentRead: useConsistentRead }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying with consistent read: ${error}`); throw error; } }
Query using a Global Secondary Index with AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table using the primary key * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} userId - The user ID to query by (partition key) * @returns {Promise<Object>} - The query response */ async function queryTable( config, tableName, userId ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Construct the query input for the base table const input = { TableName: tableName, KeyConditionExpression: "user_id = :userId", ExpressionAttributeValues: { ":userId": { S: userId } } }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying table: ${error}`); throw error; } } /** * Queries a DynamoDB Global Secondary Index (GSI) * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} indexName - The name of the GSI to query * @param {string} gameId - The game ID to query by (GSI partition key) * @returns {Promise<Object>} - The query response */ async function queryGSI( config, tableName, indexName, gameId ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Construct the query input for the GSI const input = { TableName: tableName, IndexName: indexName, KeyConditionExpression: "game_id = :gameId", ExpressionAttributeValues: { ":gameId": { S: gameId } } }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying GSI: ${error}`); throw error; } }
Query with pagination using AWS SDK for JavaScript.
/** * Example demonstrating how to handle large query result sets in DynamoDB using pagination * * This example shows: * - How to use pagination to handle large result sets * - How to use LastEvaluatedKey to retrieve the next page of results * - How to construct subsequent query requests using ExclusiveStartKey */ const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table with pagination to handle large result sets * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} partitionKeyName - The name of the partition key * @param {string} partitionKeyValue - The value of the partition key * @param {number} pageSize - Number of items per page * @returns {Promise<Array>} - All items from the query */ async function queryWithPagination( config, tableName, partitionKeyName, partitionKeyValue, pageSize = 25 ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Initialize variables for pagination let lastEvaluatedKey = undefined; const allItems = []; let pageCount = 0; // Loop until all pages are retrieved do { // Construct the query input const input = { TableName: tableName, KeyConditionExpression: "#pk = :pkValue", Limit: pageSize, ExpressionAttributeNames: { "#pk": partitionKeyName }, ExpressionAttributeValues: { ":pkValue": { S: partitionKeyValue } } }; // Add ExclusiveStartKey if we have a LastEvaluatedKey from a previous query if (lastEvaluatedKey) { input.ExclusiveStartKey = lastEvaluatedKey; } // Execute the query const command = new QueryCommand(input); const response = await client.send(command); // Process the current page of results pageCount++; console.log(`Processing page ${pageCount} with ${response.Items.length} items`); // Add the items from this page to our collection if (response.Items && response.Items.length > 0) { allItems.push(...response.Items); } // Get the LastEvaluatedKey for the next page lastEvaluatedKey = response.LastEvaluatedKey; } while (lastEvaluatedKey); // Continue until there are no more pages console.log(`Query complete. Retrieved ${allItems.length} items in ${pageCount} pages.`); return allItems; } catch (error) { console.error(`Error querying with pagination: ${error}`); throw error; } } /** * Example usage: * * // Query all items in the "AWS DynamoDB" forum with pagination * const allItems = await queryWithPagination( * { region: "us-west-2" }, * "ForumThreads", * "ForumName", * "AWS DynamoDB", * 25 // 25 items per page * ); * * console.log(`Total items retrieved: ${allItems.length}`); * * // Notes on pagination: * // - LastEvaluatedKey contains the primary key of the last evaluated item * // - When LastEvaluatedKey is undefined/null, there are no more items to retrieve * // - ExclusiveStartKey tells DynamoDB where to start the next page * // - Pagination helps manage memory usage for large result sets * // - Each page requires a separate network request to DynamoDB */ module.exports = { queryWithPagination };
Query with complex filters using AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table with a complex filter expression * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} partitionKeyName - The name of the partition key * @param {string} partitionKeyValue - The value of the partition key * @param {number|string} minViews - Minimum number of views for filtering * @param {number|string} minReplies - Minimum number of replies for filtering * @param {string} requiredTag - Tag that must be present in the item's tags set * @returns {Promise<Object>} - The query response */ async function queryWithComplexFilter( config, tableName, partitionKeyName, partitionKeyValue, minViews, minReplies, requiredTag ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Construct the query input const input = { TableName: tableName, KeyConditionExpression: "#pk = :pkValue", FilterExpression: "views >= :minViews AND replies >= :minReplies AND contains(tags, :tag)", ExpressionAttributeNames: { "#pk": partitionKeyName }, ExpressionAttributeValues: { ":pkValue": { S: partitionKeyValue }, ":minViews": { N: minViews.toString() }, ":minReplies": { N: minReplies.toString() }, ":tag": { S: requiredTag } } }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying with complex filter: ${error}`); throw error; } }
Query with a dynamically constructed filter expression using AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); async function queryWithDynamicFilter( config, tableName, partitionKeyName, partitionKeyValue, sortKeyName, sortKeyValue, filterParams = {} ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Initialize filter expression components let filterExpressions = []; const expressionAttributeValues = { ":pkValue": { S: partitionKeyValue }, ":skValue": { S: sortKeyValue } }; const expressionAttributeNames = { "#pk": partitionKeyName, "#sk": sortKeyName }; // Add status filter if provided if (filterParams.status) { filterExpressions.push("status = :status"); expressionAttributeValues[":status"] = { S: filterParams.status }; } // Add minimum views filter if provided if (filterParams.minViews !== undefined) { filterExpressions.push("views >= :minViews"); expressionAttributeValues[":minViews"] = { N: filterParams.minViews.toString() }; } // Add author filter if provided if (filterParams.author) { filterExpressions.push("author = :author"); expressionAttributeValues[":author"] = { S: filterParams.author }; } // Construct the query input const input = { TableName: tableName, KeyConditionExpression: "#pk = :pkValue AND #sk = :skValue" }; // Add filter expression if any filters were provided if (filterExpressions.length > 0) { input.FilterExpression = filterExpressions.join(" AND "); } // Add expression attribute names and values input.ExpressionAttributeNames = expressionAttributeNames; input.ExpressionAttributeValues = expressionAttributeValues; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying with dynamic filter: ${error}`); throw error; } }
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to perform list operations in DynamoDB.
Add elements to a list attribute.
Remove elements from a list attribute.
Update specific elements in a list by index.
Use list append and list index functions.
- SDK for JavaScript (v3)
-
Demonstrate list operations using AWS SDK for JavaScript.
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb"); const { DynamoDBDocumentClient, UpdateCommand, GetCommand, PutCommand } = require("@aws-sdk/lib-dynamodb"); /** * Append elements to a list attribute. * * This function demonstrates how to use the list_append function to add elements * to the end of a list. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} listName - The name of the list attribute * @param {Array} values - The values to append to the list * @returns {Promise<Object>} - The response from DynamoDB */ async function appendToList( config, tableName, key, listName, values ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using list_append const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${listName} = list_append(if_not_exists(${listName}, :empty_list), :values)`, ExpressionAttributeValues: { ":empty_list": [], ":values": values }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Prepend elements to a list attribute. * * This function demonstrates how to use the list_append function to add elements * to the beginning of a list. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} listName - The name of the list attribute * @param {Array} values - The values to prepend to the list * @returns {Promise<Object>} - The response from DynamoDB */ async function prependToList( config, tableName, key, listName, values ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using list_append // Note: To prepend, we put the new values first in the list_append function const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${listName} = list_append(:values, if_not_exists(${listName}, :empty_list))`, ExpressionAttributeValues: { ":empty_list": [], ":values": values }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Update a specific element in a list by index. * * This function demonstrates how to update a specific element in a list * using the index notation. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} listName - The name of the list attribute * @param {number} index - The index of the element to update * @param {any} value - The new value for the element * @returns {Promise<Object>} - The response from DynamoDB */ async function updateListElement( config, tableName, key, listName, index, value ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using index notation const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${listName}[${index}] = :value`, ExpressionAttributeValues: { ":value": value }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Remove an element from a list by index. * * This function demonstrates how to remove a specific element from a list * using the REMOVE action with index notation. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} listName - The name of the list attribute * @param {number} index - The index of the element to remove * @returns {Promise<Object>} - The response from DynamoDB */ async function removeListElement( config, tableName, key, listName, index ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using REMOVE with index notation const params = { TableName: tableName, Key: key, UpdateExpression: `REMOVE ${listName}[${index}]`, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Concatenate two lists. * * This function demonstrates how to concatenate two lists using the list_append function. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} listName1 - The name of the first list attribute * @param {string} listName2 - The name of the second list attribute * @param {string} resultListName - The name of the attribute to store the concatenated list * @returns {Promise<Object>} - The response from DynamoDB */ async function concatenateLists( config, tableName, key, listName1, listName2, resultListName ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using list_append const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${resultListName} = list_append(if_not_exists(${listName1}, :empty_list), if_not_exists(${listName2}, :empty_list))`, ExpressionAttributeValues: { ":empty_list": [] }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Create a nested list structure. * * This function demonstrates how to create and work with nested lists. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} listName - The name of the list attribute * @param {Array} nestedLists - An array of arrays to create a nested list structure * @returns {Promise<Object>} - The response from DynamoDB */ async function createNestedList( config, tableName, key, listName, nestedLists ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters to create a nested list const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${listName} = :nested_lists`, ExpressionAttributeValues: { ":nested_lists": nestedLists }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Update an element in a nested list. * * This function demonstrates how to update an element in a nested list * using multiple index notations. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} listName - The name of the list attribute * @param {number} outerIndex - The index in the outer list * @param {number} innerIndex - The index in the inner list * @param {any} value - The new value for the element * @returns {Promise<Object>} - The response from DynamoDB */ async function updateNestedListElement( config, tableName, key, listName, outerIndex, innerIndex, value ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using multiple index notations const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${listName}[${outerIndex}][${innerIndex}] = :value`, ExpressionAttributeValues: { ":value": value }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Get the current value of an item. * * Helper function to retrieve the current value of an item. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to get * @returns {Promise<Object|null>} - The item or null if not found */ async function getItem( config, tableName, key ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the get parameters const params = { TableName: tableName, Key: key }; // Perform the get operation const response = await docClient.send(new GetCommand(params)); // Return the item if it exists, otherwise null return response.Item || null; }
Example usage of list operations with AWS SDK for JavaScript.
/** * Example of how to work with lists in DynamoDB. */ async function exampleUsage() { // Example parameters const config = { region: "us-west-2" }; const tableName = "UserProfiles"; const key = { UserId: "U12345" }; console.log("Demonstrating list operations in DynamoDB"); try { // Example 1: Append elements to a list console.log("\nExample 1: Appending elements to a list"); const response1 = await appendToList( config, tableName, key, "RecentSearches", ["laptop", "headphones", "monitor"] ); console.log("Appended to list:", response1.Attributes); // Example 2: Prepend elements to a list console.log("\nExample 2: Prepending elements to a list"); const response2 = await prependToList( config, tableName, key, "RecentSearches", ["keyboard", "mouse"] ); console.log("Prepended to list:", response2.Attributes); // Get the current state of the item let currentItem = await getItem(config, tableName, key); console.log("\nCurrent state of RecentSearches:", currentItem?.RecentSearches); // Example 3: Update a specific element in a list console.log("\nExample 3: Updating a specific element in a list"); const response3 = await updateListElement( config, tableName, key, "RecentSearches", 0, // Update the first element "mechanical keyboard" // New value ); console.log("Updated list element:", response3.Attributes); // Example 4: Remove an element from a list console.log("\nExample 4: Removing an element from a list"); const response4 = await removeListElement( config, tableName, key, "RecentSearches", 2 // Remove the third element ); console.log("List after removing element:", response4.Attributes); // Example 5: Create and concatenate lists console.log("\nExample 5: Creating and concatenating lists"); // First, create two separate lists await updateWithMultipleActions( config, tableName, key, "SET WishList = :wishlist, SavedItems = :saveditems", null, { ":wishlist": ["gaming laptop", "wireless earbuds"], ":saveditems": ["smartphone", "tablet"] } ); // Then, concatenate them const response5 = await concatenateLists( config, tableName, key, "WishList", "SavedItems", "AllItems" ); console.log("Concatenated lists:", response5.Attributes); // Example 6: Create a nested list structure console.log("\nExample 6: Creating a nested list structure"); const response6 = await createNestedList( config, tableName, key, "Categories", [ ["Electronics", "Computers", "Accessories"], ["Books", "Magazines", "E-books"], ["Clothing", "Shoes", "Watches"] ] ); console.log("Created nested list:", response6.Attributes); // Example 7: Update an element in a nested list console.log("\nExample 7: Updating an element in a nested list"); const response7 = await updateNestedListElement( config, tableName, key, "Categories", 0, // First inner list 1, // Second element in that list "Laptops" // New value ); console.log("Updated nested list element:", response7.Attributes); // Get the final state of the item currentItem = await getItem(config, tableName, key); console.log("\nFinal state of the item:", JSON.stringify(currentItem, null, 2)); // Explain list operations console.log("\nKey points about list operations in DynamoDB:"); console.log("1. Use list_append to add elements to a list"); console.log("2. To append elements, use list_append(existingList, newElements)"); console.log("3. To prepend elements, use list_append(newElements, existingList)"); console.log("4. Use if_not_exists to handle cases where the list might not exist yet"); console.log("5. Use index notation (list[0]) to access or update specific elements"); console.log("6. Use REMOVE with index notation to remove elements from a list"); console.log("7. Lists can contain elements of different types"); console.log("8. Lists can be nested (lists of lists)"); console.log("9. Use multiple index notations (list[0][1]) to access nested list elements"); } catch (error) { console.error("Error:", error); } } /** * Helper function for the examples. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} updateExpression - The update expression * @param {Object} expressionAttributeNames - Expression attribute name placeholders * @param {Object} expressionAttributeValues - Expression attribute value placeholders * @returns {Promise<Object>} - The response from DynamoDB */ async function updateWithMultipleActions( config, tableName, key, updateExpression, expressionAttributeNames, expressionAttributeValues ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Prepare the update parameters const updateParams = { TableName: tableName, Key: key, UpdateExpression: updateExpression, ReturnValues: "UPDATED_NEW" }; // Add expression attribute names if provided if (expressionAttributeNames) { updateParams.ExpressionAttributeNames = expressionAttributeNames; } // Add expression attribute values if provided if (expressionAttributeValues) { updateParams.ExpressionAttributeValues = expressionAttributeValues; } // Execute the update const response = await docClient.send(new UpdateCommand(updateParams)); return response; }
-
For API details, see UpdateItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to perform map operations in DynamoDB.
Add and update nested attributes in map structures.
Remove specific fields from maps.
Work with deeply nested map attributes.
- SDK for JavaScript (v3)
-
Demonstrate map operations using AWS SDK for JavaScript.
/** * Example of updating map attributes in DynamoDB. * * This module demonstrates how to update map attributes that may not exist, * how to update nested attributes, and how to handle various map update scenarios. */ const { DynamoDBClient } = require("@aws-sdk/client-dynamodb"); const { DynamoDBDocumentClient, UpdateCommand, GetCommand } = require("@aws-sdk/lib-dynamodb"); /** * Update a map attribute safely, handling the case where the map might not exist. * * This function demonstrates using the if_not_exists function to safely update * a map attribute that might not exist yet. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} mapName - The name of the map attribute * @param {string} mapKey - The key within the map to update * @param {any} value - The value to set * @returns {Promise<Object>} - The response from DynamoDB */ async function updateMapAttributeSafe( config, tableName, key, mapName, mapKey, value ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using SET with if_not_exists const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${mapName}.${mapKey} = :value`, ExpressionAttributeValues: { ":value": value }, ReturnValues: "UPDATED_NEW" }; try { // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } catch (error) { // If the error is because the map doesn't exist, create it if (error.name === "ValidationException" && error.message.includes("The document path provided in the update expression is invalid")) { // Create the map with the specified key-value pair const createParams = { TableName: tableName, Key: key, UpdateExpression: `SET ${mapName} = :map`, ExpressionAttributeValues: { ":map": { [mapKey]: value } }, ReturnValues: "UPDATED_NEW" }; return await docClient.send(new UpdateCommand(createParams)); } // Re-throw other errors throw error; } } /** * Update a map attribute using the if_not_exists function. * * This function demonstrates a more elegant approach using if_not_exists * to handle the case where the map doesn't exist yet. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} mapName - The name of the map attribute * @param {string} mapKey - The key within the map to update * @param {any} value - The value to set * @returns {Promise<Object>} - The response from DynamoDB */ async function updateMapAttributeWithIfNotExists( config, tableName, key, mapName, mapKey, value ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using SET with if_not_exists const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${mapName} = if_not_exists(${mapName}, :emptyMap), ${mapName}.${mapKey} = :value`, ExpressionAttributeValues: { ":emptyMap": {}, ":value": value }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Add a value to a deeply nested map, creating parent maps if they don't exist. * * This function demonstrates how to update a deeply nested attribute, * creating any parent maps that don't exist along the way. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string[]} path - The path to the nested attribute as an array of keys * @param {any} value - The value to set * @returns {Promise<Object>} - The response from DynamoDB */ async function addToNestedMap( config, tableName, key, path, value ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Build the update expression and expression attribute values let updateExpression = "SET"; const expressionAttributeValues = {}; // For each level in the path, create a map if it doesn't exist for (let i = 0; i < path.length; i++) { const currentPath = path.slice(0, i + 1).join("."); const parentPath = i > 0 ? path.slice(0, i).join(".") : null; if (parentPath) { updateExpression += ` ${parentPath} = if_not_exists(${parentPath}, :emptyMap${i}),`; expressionAttributeValues[`:emptyMap${i}`] = {}; } } // Set the final value const fullPath = path.join("."); updateExpression += ` ${fullPath} = :value`; expressionAttributeValues[":value"] = value; // Define the update parameters const params = { TableName: tableName, Key: key, UpdateExpression: updateExpression, ExpressionAttributeValues: expressionAttributeValues, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Update multiple fields in a map attribute in a single operation. * * This function demonstrates how to update multiple fields in a map * in a single DynamoDB operation. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} mapName - The name of the map attribute * @param {Object} updates - Object containing key-value pairs to update * @returns {Promise<Object>} - The response from DynamoDB */ async function updateMultipleMapFields( config, tableName, key, mapName, updates ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Build the update expression and expression attribute values let updateExpression = `SET ${mapName} = if_not_exists(${mapName}, :emptyMap)`; const expressionAttributeValues = { ":emptyMap": {} }; // Add each update to the expression Object.entries(updates).forEach(([field, value], index) => { updateExpression += `, ${mapName}.${field} = :val${index}`; expressionAttributeValues[`:val${index}`] = value; }); // Define the update parameters const params = { TableName: tableName, Key: key, UpdateExpression: updateExpression, ExpressionAttributeValues: expressionAttributeValues, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Get the current value of an item. * * Helper function to retrieve the current value of an item. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to get * @returns {Promise<Object|null>} - The item or null if not found */ async function getItem( config, tableName, key ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the get parameters const params = { TableName: tableName, Key: key }; // Perform the get operation const response = await docClient.send(new GetCommand(params)); // Return the item if it exists, otherwise null return response.Item || null; } /** * Example of how to use the map attribute update functions. */ async function exampleUsage() { // Example parameters const config = { region: "us-west-2" }; const tableName = "Users"; const key = { UserId: "U12345" }; console.log("Demonstrating different approaches to update map attributes in DynamoDB"); try { // Example 1: Update a map attribute that might not exist (two-step approach) console.log("\nExample 1: Updating a map attribute that might not exist (two-step approach)"); const response1 = await updateMapAttributeSafe( config, tableName, key, "Preferences", "Theme", "Dark" ); console.log("Updated preferences:", response1.Attributes); // Example 2: Update a map attribute using if_not_exists (elegant approach) console.log("\nExample 2: Updating a map attribute using if_not_exists (elegant approach)"); const response2 = await updateMapAttributeWithIfNotExists( config, tableName, key, "Settings", "NotificationsEnabled", true ); console.log("Updated settings:", response2.Attributes); // Example 3: Update a deeply nested attribute console.log("\nExample 3: Updating a deeply nested attribute"); const response3 = await addToNestedMap( config, tableName, key, ["Profile", "Address", "City"], "Seattle" ); console.log("Updated nested attribute:", response3.Attributes); // Example 4: Update multiple fields in a map console.log("\nExample 4: Updating multiple fields in a map"); const response4 = await updateMultipleMapFields( config, tableName, key, "ContactInfo", { Email: "[email protected]", Phone: "555-123-4567", PreferredContact: "Email" } ); console.log("Updated multiple fields:", response4.Attributes); // Get the final state of the item console.log("\nFinal state of the item:"); const item = await getItem(config, tableName, key); console.log(JSON.stringify(item, null, 2)); // Explain the benefits of different approaches console.log("\nKey points about updating map attributes:"); console.log("1. Use if_not_exists to handle maps that might not exist"); console.log("2. Multiple updates can be combined in a single operation"); console.log("3. Deeply nested attributes require creating parent maps"); console.log("4. DynamoDB expressions are atomic - the entire update succeeds or fails"); console.log("5. Using a single operation is more efficient than multiple separate updates"); } catch (error) { console.error("Error:", error); } } // Export the functions module.exports = { updateMapAttributeSafe, updateMapAttributeWithIfNotExists, addToNestedMap, updateMultipleMapFields, getItem, exampleUsage }; // Run the example if this file is executed directly if (require.main === module) { exampleUsage(); }
-
For API details, see UpdateItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to perform set operations in DynamoDB.
Add elements to a set attribute.
Remove elements from a set attribute.
Use ADD and DELETE operations with sets.
- SDK for JavaScript (v3)
-
Demonstrate set operations using AWS SDK for JavaScript.
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb"); const { DynamoDBDocumentClient, UpdateCommand, GetCommand } = require("@aws-sdk/lib-dynamodb"); /** * Add elements to a set attribute. * * This function demonstrates using the ADD operation to add elements to a set. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} setName - The name of the set attribute * @param {Array} values - The values to add to the set * @param {string} setType - The type of set ('string', 'number', or 'binary') * @returns {Promise<Object>} - The response from DynamoDB */ async function addToSet( config, tableName, key, setName, values, setType = 'string' ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Create the appropriate set type let setValues; if (setType === 'string') { setValues = new Set(values.map(String)); } else if (setType === 'number') { setValues = new Set(values.map(Number)); } else if (setType === 'binary') { setValues = new Set(values); } else { throw new Error(`Unsupported set type: ${setType}`); } // Define the update parameters using ADD const params = { TableName: tableName, Key: key, UpdateExpression: `ADD ${setName} :values`, ExpressionAttributeValues: { ":values": setValues }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Remove elements from a set attribute. * * This function demonstrates using the DELETE operation to remove elements from a set. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} setName - The name of the set attribute * @param {Array} values - The values to remove from the set * @param {string} setType - The type of set ('string', 'number', or 'binary') * @returns {Promise<Object>} - The response from DynamoDB */ async function removeFromSet( config, tableName, key, setName, values, setType = 'string' ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Create the appropriate set type let setValues; if (setType === 'string') { setValues = new Set(values.map(String)); } else if (setType === 'number') { setValues = new Set(values.map(Number)); } else if (setType === 'binary') { setValues = new Set(values); } else { throw new Error(`Unsupported set type: ${setType}`); } // Define the update parameters using DELETE const params = { TableName: tableName, Key: key, UpdateExpression: `DELETE ${setName} :values`, ExpressionAttributeValues: { ":values": setValues }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Create a new set attribute with initial values. * * This function demonstrates using the SET operation to create a new set attribute. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} setName - The name of the set attribute * @param {Array} values - The initial values for the set * @param {string} setType - The type of set ('string', 'number', or 'binary') * @returns {Promise<Object>} - The response from DynamoDB */ async function createSet( config, tableName, key, setName, values, setType = 'string' ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Create the appropriate set type let setValues; if (setType === 'string') { setValues = new Set(values.map(String)); } else if (setType === 'number') { setValues = new Set(values.map(Number)); } else if (setType === 'binary') { setValues = new Set(values); } else { throw new Error(`Unsupported set type: ${setType}`); } // Define the update parameters using SET const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${setName} = :values`, ExpressionAttributeValues: { ":values": setValues }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Replace an entire set attribute with a new set of values. * * This function demonstrates using the SET operation to replace an entire set. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} setName - The name of the set attribute * @param {Array} values - The new values for the set * @param {string} setType - The type of set ('string', 'number', or 'binary') * @returns {Promise<Object>} - The response from DynamoDB */ async function replaceSet( config, tableName, key, setName, values, setType = 'string' ) { // This is the same as createSet, but included for clarity of intent return await createSet(config, tableName, key, setName, values, setType); } /** * Remove the last element from a set and handle the empty set case. * * This function demonstrates what happens when you delete the last element of a set. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} setName - The name of the set attribute * @returns {Promise<Object>} - The result of the operation */ async function removeLastElementFromSet( config, tableName, key, setName ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // First, get the current item to check the set const currentItem = await getItem(config, tableName, key); // Check if the set exists and has elements if (!currentItem || !currentItem[setName] || currentItem[setName].size === 0) { return { success: false, message: "Set doesn't exist or is already empty", item: currentItem }; } // Get the set values const setValues = Array.from(currentItem[setName]); // If there's only one element left, remove the attribute entirely if (setValues.length === 1) { // Define the update parameters to remove the attribute const params = { TableName: tableName, Key: key, UpdateExpression: `REMOVE ${setName}`, ReturnValues: "UPDATED_NEW" }; // Perform the update operation await docClient.send(new UpdateCommand(params)); return { success: true, message: "Last element removed, attribute has been deleted", removedValue: setValues[0] }; } else { // Otherwise, remove just the last element // Create a set with just the last element const lastElement = setValues[setValues.length - 1]; const setType = typeof lastElement === 'number' ? 'number' : 'string'; // Remove the last element const response = await removeFromSet( config, tableName, key, setName, [lastElement], setType ); return { success: true, message: "Last element removed, set still contains elements", removedValue: lastElement, remainingSet: response.Attributes[setName] }; } } /** * Get the current value of an item. * * Helper function to retrieve the current value of an item. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to get * @returns {Promise<Object|null>} - The item or null if not found */ async function getItem( config, tableName, key ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the get parameters const params = { TableName: tableName, Key: key }; // Perform the get operation const response = await docClient.send(new GetCommand(params)); // Return the item if it exists, otherwise null return response.Item || null; }
Example usage of set operations with AWS SDK for JavaScript.
/** * Example of how to work with sets in DynamoDB. */ async function exampleUsage() { // Example parameters const config = { region: "us-west-2" }; const tableName = "Users"; const key = { UserId: "U12345" }; console.log("Demonstrating set operations in DynamoDB"); try { // Example 1: Create a string set console.log("\nExample 1: Creating a string set"); const response1 = await createSet( config, tableName, key, "Interests", ["Reading", "Hiking", "Cooking"], "string" ); console.log("Created set:", response1.Attributes); // Example 2: Add elements to a set console.log("\nExample 2: Adding elements to a set"); const response2 = await addToSet( config, tableName, key, "Interests", ["Photography", "Travel"], "string" ); console.log("Updated set after adding elements:", response2.Attributes); // Example 3: Remove elements from a set console.log("\nExample 3: Removing elements from a set"); const response3 = await removeFromSet( config, tableName, key, "Interests", ["Cooking"], "string" ); console.log("Updated set after removing elements:", response3.Attributes); // Example 4: Create a number set console.log("\nExample 4: Creating a number set"); const response4 = await createSet( config, tableName, key, "FavoriteNumbers", [7, 42, 99], "number" ); console.log("Created number set:", response4.Attributes); // Example 5: Replace an entire set console.log("\nExample 5: Replacing an entire set"); const response5 = await replaceSet( config, tableName, key, "Interests", ["Gaming", "Movies", "Music"], "string" ); console.log("Replaced set:", response5.Attributes); // Example 6: Remove the last element from a set console.log("\nExample 6: Removing the last element from a set"); // First, create a set with just one element await createSet( config, tableName, { UserId: "U67890" }, "Tags", ["LastTag"], "string" ); // Then, remove the last element const response6 = await removeLastElementFromSet( config, tableName, { UserId: "U67890" }, "Tags" ); console.log(response6.message); console.log("Removed value:", response6.removedValue); // Get the final state of the items console.log("\nFinal state of the items:"); const item1 = await getItem(config, tableName, key); console.log("User U12345:", JSON.stringify(item1, null, 2)); const item2 = await getItem(config, tableName, { UserId: "U67890" }); console.log("User U67890:", JSON.stringify(item2, null, 2)); // Explain set operations console.log("\nKey points about set operations in DynamoDB:"); console.log("1. Use ADD to add elements to a set (duplicates are automatically removed)"); console.log("2. Use DELETE to remove elements from a set"); console.log("3. Use SET to create a new set or replace an existing one"); console.log("4. DynamoDB supports three types of sets: string sets, number sets, and binary sets"); console.log("5. When you delete the last element from a set, the attribute remains as an empty set"); console.log("6. To remove an empty set, use the REMOVE operation"); console.log("7. Sets automatically maintain unique values (no duplicates)"); console.log("8. You cannot mix data types within a set"); } catch (error) { console.error("Error:", error); } }
-
For API details, see UpdateItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to:
Get a batch of items by running multiple SELECT statements.
Add a batch of items by running multiple INSERT statements.
Update a batch of items by running multiple UPDATE statements.
Delete a batch of items by running multiple DELETE statements.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. Execute batch PartiQL statements.
import { BillingMode, CreateTableCommand, DeleteTableCommand, DescribeTableCommand, DynamoDBClient, waitUntilTableExists, } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, BatchExecuteStatementCommand, } from "@aws-sdk/lib-dynamodb"; import { ScenarioInput } from "@aws-doc-sdk-examples/lib/scenario"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const log = (msg) => console.log(`[SCENARIO] ${msg}`); const tableName = "Cities"; export const main = async (confirmAll = false) => { /** * Delete table if it exists. */ try { await client.send(new DescribeTableCommand({ TableName: tableName })); // If no error was thrown, the table exists. const input = new ScenarioInput( "deleteTable", `A table named ${tableName} already exists. If you choose not to delete this table, the scenario cannot continue. Delete it?`, { type: "confirm", confirmAll }, ); const deleteTable = await input.handle({}, { confirmAll }); if (deleteTable) { await client.send(new DeleteTableCommand({ tableName })); } else { console.warn( "Scenario could not run. Either delete ${tableName} or provide a unique table name.", ); return; } } catch (caught) { if ( caught instanceof Error && caught.name === "ResourceNotFoundException" ) { // Do nothing. This means the table is not there. } else { throw caught; } } /** * Create a table. */ log("Creating a table."); const createTableCommand = new CreateTableCommand({ TableName: tableName, // This example performs a large write to the database. // Set the billing mode to PAY_PER_REQUEST to // avoid throttling the large write. BillingMode: BillingMode.PAY_PER_REQUEST, // Define the attributes that are necessary for the key schema. AttributeDefinitions: [ { AttributeName: "name", // 'S' is a data type descriptor that represents a number type. // For a list of all data type descriptors, see the following link. // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html#Programming.LowLevelAPI.DataTypeDescriptors AttributeType: "S", }, ], // The KeySchema defines the primary key. The primary key can be // a partition key, or a combination of a partition key and a sort key. // Key schema design is important. For more info, see // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html KeySchema: [{ AttributeName: "name", KeyType: "HASH" }], }); await client.send(createTableCommand); log(`Table created: ${tableName}.`); /** * Wait until the table is active. */ // This polls with DescribeTableCommand until the requested table is 'ACTIVE'. // You can't write to a table before it's active. log("Waiting for the table to be active."); await waitUntilTableExists({ client }, { TableName: tableName }); log("Table active."); /** * Insert items. */ log("Inserting cities into the table."); const addItemsStatementCommand = new BatchExecuteStatementCommand({ // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.insert.html Statements: [ { Statement: `INSERT INTO ${tableName} value {'name':?, 'population':?}`, Parameters: ["Alachua", 10712], }, { Statement: `INSERT INTO ${tableName} value {'name':?, 'population':?}`, Parameters: ["High Springs", 6415], }, ], }); await docClient.send(addItemsStatementCommand); log("Cities inserted."); /** * Select items. */ log("Selecting cities from the table."); const selectItemsStatementCommand = new BatchExecuteStatementCommand({ // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html Statements: [ { Statement: `SELECT * FROM ${tableName} WHERE name=?`, Parameters: ["Alachua"], }, { Statement: `SELECT * FROM ${tableName} WHERE name=?`, Parameters: ["High Springs"], }, ], }); const selectItemResponse = await docClient.send(selectItemsStatementCommand); log( `Got cities: ${selectItemResponse.Responses.map( (r) => `${r.Item.name} (${r.Item.population})`, ).join(", ")}`, ); /** * Update items. */ log("Modifying the populations."); const updateItemStatementCommand = new BatchExecuteStatementCommand({ // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.update.html Statements: [ { Statement: `UPDATE ${tableName} SET population=? WHERE name=?`, Parameters: [10, "Alachua"], }, { Statement: `UPDATE ${tableName} SET population=? WHERE name=?`, Parameters: [5, "High Springs"], }, ], }); await docClient.send(updateItemStatementCommand); log("Updated cities."); /** * Delete the items. */ log("Deleting the cities."); const deleteItemStatementCommand = new BatchExecuteStatementCommand({ // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.delete.html Statements: [ { Statement: `DELETE FROM ${tableName} WHERE name=?`, Parameters: ["Alachua"], }, { Statement: `DELETE FROM ${tableName} WHERE name=?`, Parameters: ["High Springs"], }, ], }); await docClient.send(deleteItemStatementCommand); log("Cities deleted."); /** * Delete the table. */ log("Deleting the table."); const deleteTableCommand = new DeleteTableCommand({ TableName: tableName }); await client.send(deleteTableCommand); log("Table deleted."); };
-
For API details, see BatchExecuteStatement in AWS SDK for JavaScript API Reference.
-
The following code example shows how to:
Get an item by running a SELECT statement.
Add an item by running an INSERT statement.
Update an item by running an UPDATE statement.
Delete an item by running a DELETE statement.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the AWS Code Examples Repository
. Execute single PartiQL statements.
import { BillingMode, CreateTableCommand, DeleteTableCommand, DescribeTableCommand, DynamoDBClient, waitUntilTableExists, } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, ExecuteStatementCommand, } from "@aws-sdk/lib-dynamodb"; import { ScenarioInput } from "@aws-doc-sdk-examples/lib/scenario"; const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const log = (msg) => console.log(`[SCENARIO] ${msg}`); const tableName = "SingleOriginCoffees"; export const main = async (confirmAll = false) => { /** * Delete table if it exists. */ try { await client.send(new DescribeTableCommand({ TableName: tableName })); // If no error was thrown, the table exists. const input = new ScenarioInput( "deleteTable", `A table named ${tableName} already exists. If you choose not to delete this table, the scenario cannot continue. Delete it?`, { type: "confirm", confirmAll }, ); const deleteTable = await input.handle({}); if (deleteTable) { await client.send(new DeleteTableCommand({ tableName })); } else { console.warn( "Scenario could not run. Either delete ${tableName} or provide a unique table name.", ); return; } } catch (caught) { if ( caught instanceof Error && caught.name === "ResourceNotFoundException" ) { // Do nothing. This means the table is not there. } else { throw caught; } } /** * Create a table. */ log("Creating a table."); const createTableCommand = new CreateTableCommand({ TableName: tableName, // This example performs a large write to the database. // Set the billing mode to PAY_PER_REQUEST to // avoid throttling the large write. BillingMode: BillingMode.PAY_PER_REQUEST, // Define the attributes that are necessary for the key schema. AttributeDefinitions: [ { AttributeName: "varietal", // 'S' is a data type descriptor that represents a number type. // For a list of all data type descriptors, see the following link. // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html#Programming.LowLevelAPI.DataTypeDescriptors AttributeType: "S", }, ], // The KeySchema defines the primary key. The primary key can be // a partition key, or a combination of a partition key and a sort key. // Key schema design is important. For more info, see // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/best-practices.html KeySchema: [{ AttributeName: "varietal", KeyType: "HASH" }], }); await client.send(createTableCommand); log(`Table created: ${tableName}.`); /** * Wait until the table is active. */ // This polls with DescribeTableCommand until the requested table is 'ACTIVE'. // You can't write to a table before it's active. log("Waiting for the table to be active."); await waitUntilTableExists({ client }, { TableName: tableName }); log("Table active."); /** * Insert an item. */ log("Inserting a coffee into the table."); const addItemStatementCommand = new ExecuteStatementCommand({ // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.insert.html Statement: `INSERT INTO ${tableName} value {'varietal':?, 'profile':?}`, Parameters: ["arabica", ["chocolate", "floral"]], }); await client.send(addItemStatementCommand); log("Coffee inserted."); /** * Select an item. */ log("Selecting the coffee from the table."); const selectItemStatementCommand = new ExecuteStatementCommand({ // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html Statement: `SELECT * FROM ${tableName} WHERE varietal=?`, Parameters: ["arabica"], }); const selectItemResponse = await docClient.send(selectItemStatementCommand); log(`Got coffee: ${JSON.stringify(selectItemResponse.Items[0])}`); /** * Update the item. */ log("Add a flavor profile to the coffee."); const updateItemStatementCommand = new ExecuteStatementCommand({ // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.update.html Statement: `UPDATE ${tableName} SET profile=list_append(profile, ?) WHERE varietal=?`, Parameters: [["fruity"], "arabica"], }); await client.send(updateItemStatementCommand); log("Updated coffee"); /** * Delete the item. */ log("Deleting the coffee."); const deleteItemStatementCommand = new ExecuteStatementCommand({ // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.delete.html Statement: `DELETE FROM ${tableName} WHERE varietal=?`, Parameters: ["arabica"], }); await docClient.send(deleteItemStatementCommand); log("Coffee deleted."); /** * Delete the table. */ log("Deleting the table."); const deleteTableCommand = new DeleteTableCommand({ TableName: tableName }); await client.send(deleteTableCommand); log("Table deleted."); };
-
For API details, see ExecuteStatement in AWS SDK for JavaScript API Reference.
-
The following code example shows how to query a table using a Global Secondary Index.
Query a DynamoDB table using its primary key.
Query a Global Secondary Index (GSI) for alternate access patterns.
Compare table queries and GSI queries.
- SDK for JavaScript (v3)
-
Query a DynamoDB table using the primary key with AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table using the primary key * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} userId - The user ID to query by (partition key) * @returns {Promise<Object>} - The query response */ async function queryTable( config, tableName, userId ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Construct the query input for the base table const input = { TableName: tableName, KeyConditionExpression: "user_id = :userId", ExpressionAttributeValues: { ":userId": { S: userId } } }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying table: ${error}`); throw error; } }
Query a DynamoDB Global Secondary Index (GSI) with AWS SDK for JavaScript.
/** * Queries a DynamoDB Global Secondary Index (GSI) * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} indexName - The name of the GSI to query * @param {string} gameId - The game ID to query by (GSI partition key) * @returns {Promise<Object>} - The query response */ async function queryGSI( config, tableName, indexName, gameId ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Construct the query input for the GSI const input = { TableName: tableName, IndexName: indexName, KeyConditionExpression: "game_id = :gameId", ExpressionAttributeValues: { ":gameId": { S: gameId } } }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying GSI: ${error}`); throw error; } }
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to query a table using a begins_with condition.
Use the begins_with function in a key condition expression.
Filter items based on a prefix pattern in the sort key.
- SDK for JavaScript (v3)
-
Query a DynamoDB table using a begins_with condition on the sort key with AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table for items where the sort key begins with a specific prefix * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} partitionKeyName - The name of the partition key * @param {string} partitionKeyValue - The value of the partition key * @param {string} sortKeyName - The name of the sort key * @param {string} prefix - The prefix to match at the beginning of the sort key * @returns {Promise<Object>} - The query response */ async function queryWithBeginsWith( config, tableName, partitionKeyName, partitionKeyValue, sortKeyName, prefix ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Construct the query input const input = { TableName: tableName, KeyConditionExpression: "#pk = :pkValue AND begins_with(#sk, :prefix)", ExpressionAttributeNames: { "#pk": partitionKeyName, "#sk": sortKeyName }, ExpressionAttributeValues: { ":pkValue": { S: partitionKeyValue }, ":prefix": { S: prefix } } }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying with begins_with: ${error}`); throw error; } }
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to query a table using a date range in the sort key.
Query items within a specific date range.
Use comparison operators on date-formatted sort keys.
- SDK for JavaScript (v3)
-
Query a DynamoDB table for items within a date range with AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table for items within a specific date range on the sort key * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} partitionKeyName - The name of the partition key * @param {string} partitionKeyValue - The value of the partition key * @param {string} sortKeyName - The name of the sort key (must be a date/time attribute) * @param {Date} startDate - The start date for the range query * @param {Date} endDate - The end date for the range query * @returns {Promise<Object>} - The query response */ async function queryByDateRangeOnSortKey( config, tableName, partitionKeyName, partitionKeyValue, sortKeyName, startDate, endDate ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Format dates as ISO strings for DynamoDB const formattedStartDate = startDate.toISOString(); const formattedEndDate = endDate.toISOString(); // Construct the query input const input = { TableName: tableName, KeyConditionExpression: '#pk = :pkValue AND #sk BETWEEN :startDate AND :endDate', ExpressionAttributeNames: { "#pk": partitionKeyName, "#sk": sortKeyName }, ExpressionAttributeValues: { ":pkValue": { S: partitionKeyValue }, ":startDate": { S: formattedStartDate }, ":endDate": { S: formattedEndDate } } }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying by date range on sort key: ${error}`); throw error; } }
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to query a table with a complex filter expression.
Apply complex filter expressions to query results.
Combine multiple conditions using logical operators.
Filter items based on non-key attributes.
- SDK for JavaScript (v3)
-
Query a DynamoDB table with a complex filter expression using AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table with a complex filter expression * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} partitionKeyName - The name of the partition key * @param {string} partitionKeyValue - The value of the partition key * @param {number|string} minViews - Minimum number of views for filtering * @param {number|string} minReplies - Minimum number of replies for filtering * @param {string} requiredTag - Tag that must be present in the item's tags set * @returns {Promise<Object>} - The query response */ async function queryWithComplexFilter( config, tableName, partitionKeyName, partitionKeyValue, minViews, minReplies, requiredTag ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Construct the query input const input = { TableName: tableName, KeyConditionExpression: "#pk = :pkValue", FilterExpression: "views >= :minViews AND replies >= :minReplies AND contains(tags, :tag)", ExpressionAttributeNames: { "#pk": partitionKeyName }, ExpressionAttributeValues: { ":pkValue": { S: partitionKeyValue }, ":minViews": { N: minViews.toString() }, ":minReplies": { N: minReplies.toString() }, ":tag": { S: requiredTag } } }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying with complex filter: ${error}`); throw error; } }
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to query a table with a dynamic filter expression.
Build filter expressions dynamically at runtime.
Construct filter conditions based on user input or application state.
Add or remove filter criteria conditionally.
- SDK for JavaScript (v3)
-
Query a DynamoDB table with a dynamically constructed filter expression using AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); async function queryWithDynamicFilter( config, tableName, partitionKeyName, partitionKeyValue, sortKeyName, sortKeyValue, filterParams = {} ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Initialize filter expression components let filterExpressions = []; const expressionAttributeValues = { ":pkValue": { S: partitionKeyValue }, ":skValue": { S: sortKeyValue } }; const expressionAttributeNames = { "#pk": partitionKeyName, "#sk": sortKeyName }; // Add status filter if provided if (filterParams.status) { filterExpressions.push("status = :status"); expressionAttributeValues[":status"] = { S: filterParams.status }; } // Add minimum views filter if provided if (filterParams.minViews !== undefined) { filterExpressions.push("views >= :minViews"); expressionAttributeValues[":minViews"] = { N: filterParams.minViews.toString() }; } // Add author filter if provided if (filterParams.author) { filterExpressions.push("author = :author"); expressionAttributeValues[":author"] = { S: filterParams.author }; } // Construct the query input const input = { TableName: tableName, KeyConditionExpression: "#pk = :pkValue AND #sk = :skValue" }; // Add filter expression if any filters were provided if (filterExpressions.length > 0) { input.FilterExpression = filterExpressions.join(" AND "); } // Add expression attribute names and values input.ExpressionAttributeNames = expressionAttributeNames; input.ExpressionAttributeValues = expressionAttributeValues; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying with dynamic filter: ${error}`); throw error; } }
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to query a table with nested attributes.
Access and filter by nested attributes in DynamoDB items.
Use document path expressions to reference nested elements.
- SDK for JavaScript (v3)
-
Query a DynamoDB table with nested attributes using AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table filtering on a nested attribute * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} productId - The product ID to query by (partition key) * @param {string} category - The category to filter by (nested attribute) * @returns {Promise<Object>} - The query response */ async function queryWithNestedAttribute( config, tableName, productId, category ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Construct the query input const input = { TableName: tableName, KeyConditionExpression: "product_id = :productId", FilterExpression: "details.category = :category", ExpressionAttributeValues: { ":productId": { S: productId }, ":category": { S: category } } }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying with nested attribute: ${error}`); throw error; } }
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to query a table with pagination.
Implement pagination for DynamoDB query results.
Use the LastEvaluatedKey to retrieve subsequent pages.
Control the number of items per page with the Limit parameter.
- SDK for JavaScript (v3)
-
Query a DynamoDB table with pagination using AWS SDK for JavaScript.
/** * Example demonstrating how to handle large query result sets in DynamoDB using pagination * * This example shows: * - How to use pagination to handle large result sets * - How to use LastEvaluatedKey to retrieve the next page of results * - How to construct subsequent query requests using ExclusiveStartKey */ const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table with pagination to handle large result sets * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} partitionKeyName - The name of the partition key * @param {string} partitionKeyValue - The value of the partition key * @param {number} pageSize - Number of items per page * @returns {Promise<Array>} - All items from the query */ async function queryWithPagination( config, tableName, partitionKeyName, partitionKeyValue, pageSize = 25 ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Initialize variables for pagination let lastEvaluatedKey = undefined; const allItems = []; let pageCount = 0; // Loop until all pages are retrieved do { // Construct the query input const input = { TableName: tableName, KeyConditionExpression: "#pk = :pkValue", Limit: pageSize, ExpressionAttributeNames: { "#pk": partitionKeyName }, ExpressionAttributeValues: { ":pkValue": { S: partitionKeyValue } } }; // Add ExclusiveStartKey if we have a LastEvaluatedKey from a previous query if (lastEvaluatedKey) { input.ExclusiveStartKey = lastEvaluatedKey; } // Execute the query const command = new QueryCommand(input); const response = await client.send(command); // Process the current page of results pageCount++; console.log(`Processing page ${pageCount} with ${response.Items.length} items`); // Add the items from this page to our collection if (response.Items && response.Items.length > 0) { allItems.push(...response.Items); } // Get the LastEvaluatedKey for the next page lastEvaluatedKey = response.LastEvaluatedKey; } while (lastEvaluatedKey); // Continue until there are no more pages console.log(`Query complete. Retrieved ${allItems.length} items in ${pageCount} pages.`); return allItems; } catch (error) { console.error(`Error querying with pagination: ${error}`); throw error; } } /** * Example usage: * * // Query all items in the "AWS DynamoDB" forum with pagination * const allItems = await queryWithPagination( * { region: "us-west-2" }, * "ForumThreads", * "ForumName", * "AWS DynamoDB", * 25 // 25 items per page * ); * * console.log(`Total items retrieved: ${allItems.length}`); * * // Notes on pagination: * // - LastEvaluatedKey contains the primary key of the last evaluated item * // - When LastEvaluatedKey is undefined/null, there are no more items to retrieve * // - ExclusiveStartKey tells DynamoDB where to start the next page * // - Pagination helps manage memory usage for large result sets * // - Each page requires a separate network request to DynamoDB */ module.exports = { queryWithPagination };
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to query a table with strongly consistent reads.
Configure the consistency level for DynamoDB queries.
Use strongly consistent reads to get the most up-to-date data.
Understand the tradeoffs between eventual consistency and strong consistency.
- SDK for JavaScript (v3)
-
Query a DynamoDB table with configurable read consistency using AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table with configurable read consistency * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} partitionKeyName - The name of the partition key * @param {string} partitionKeyValue - The value of the partition key * @param {boolean} useConsistentRead - Whether to use strongly consistent reads * @returns {Promise<Object>} - The query response */ async function queryWithConsistentRead( config, tableName, partitionKeyName, partitionKeyValue, useConsistentRead = false ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Construct the query input const input = { TableName: tableName, KeyConditionExpression: "#pk = :pkValue", ExpressionAttributeNames: { "#pk": partitionKeyName }, ExpressionAttributeValues: { ":pkValue": { S: partitionKeyValue } }, ConsistentRead: useConsistentRead }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying with consistent read: ${error}`); throw error; } }
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to query data using PartiQL SELECT statements.
- SDK for JavaScript (v3)
-
Query items from a DynamoDB table using PartiQL SELECT statements with AWS SDK for JavaScript.
/** * This example demonstrates how to query items from a DynamoDB table using PartiQL. * It shows different ways to select data with various index types. */ import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, ExecuteStatementCommand, BatchExecuteStatementCommand, } from "@aws-sdk/lib-dynamodb"; /** * Select all items from a DynamoDB table using PartiQL. * Note: This should be used with caution on large tables. * * @param tableName - The name of the DynamoDB table * @returns The response from the ExecuteStatementCommand */ export const selectAllItems = async (tableName: string) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `SELECT * FROM "${tableName}"`, }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Items retrieved successfully"); return data; } catch (err) { console.error("Error retrieving items:", err); throw err; } }; /** * Select an item by its primary key using PartiQL. * * @param tableName - The name of the DynamoDB table * @param partitionKeyName - The name of the partition key attribute * @param partitionKeyValue - The value of the partition key * @returns The response from the ExecuteStatementCommand */ export const selectItemByPartitionKey = async ( tableName: string, partitionKeyName: string, partitionKeyValue: string | number ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `SELECT * FROM "${tableName}" WHERE ${partitionKeyName} = ?`, Parameters: [partitionKeyValue], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Item retrieved successfully"); return data; } catch (err) { console.error("Error retrieving item:", err); throw err; } }; /** * Select an item by its composite key (partition key + sort key) using PartiQL. * * @param tableName - The name of the DynamoDB table * @param partitionKeyName - The name of the partition key attribute * @param partitionKeyValue - The value of the partition key * @param sortKeyName - The name of the sort key attribute * @param sortKeyValue - The value of the sort key * @returns The response from the ExecuteStatementCommand */ export const selectItemByCompositeKey = async ( tableName: string, partitionKeyName: string, partitionKeyValue: string | number, sortKeyName: string, sortKeyValue: string | number ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `SELECT * FROM "${tableName}" WHERE ${partitionKeyName} = ? AND ${sortKeyName} = ?`, Parameters: [partitionKeyValue, sortKeyValue], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Item retrieved successfully"); return data; } catch (err) { console.error("Error retrieving item:", err); throw err; } }; /** * Select items using a filter condition with PartiQL. * * @param tableName - The name of the DynamoDB table * @param filterAttribute - The attribute to filter on * @param filterValue - The value to filter by * @returns The response from the ExecuteStatementCommand */ export const selectItemsWithFilter = async ( tableName: string, filterAttribute: string, filterValue: string | number ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `SELECT * FROM "${tableName}" WHERE ${filterAttribute} = ?`, Parameters: [filterValue], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Items retrieved successfully"); return data; } catch (err) { console.error("Error retrieving items:", err); throw err; } }; /** * Select items using a begins_with function for prefix matching. * This is useful for querying hierarchical data. * * @param tableName - The name of the DynamoDB table * @param attributeName - The attribute to check for prefix * @param prefix - The prefix to match * @returns The response from the ExecuteStatementCommand */ export const selectItemsByPrefix = async ( tableName: string, attributeName: string, prefix: string ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `SELECT * FROM "${tableName}" WHERE begins_with(${attributeName}, ?)`, Parameters: [prefix], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Items retrieved successfully"); return data; } catch (err) { console.error("Error retrieving items:", err); throw err; } }; /** * Select items using a between condition for range queries. * * @param tableName - The name of the DynamoDB table * @param attributeName - The attribute to check for range * @param startValue - The start value of the range * @param endValue - The end value of the range * @returns The response from the ExecuteStatementCommand */ export const selectItemsByRange = async ( tableName: string, attributeName: string, startValue: number | string, endValue: number | string ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `SELECT * FROM "${tableName}" WHERE ${attributeName} BETWEEN ? AND ?`, Parameters: [startValue, endValue], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Items retrieved successfully"); return data; } catch (err) { console.error("Error retrieving items:", err); throw err; } }; /** * Example usage showing how to select items with different index types */ export const selectExamples = async () => { // Select all items from a table (use with caution on large tables) await selectAllItems("UsersTable"); // Select by partition key (simple primary key) await selectItemByPartitionKey("UsersTable", "userId", "user123"); // Select by composite key (partition key + sort key) await selectItemByCompositeKey("OrdersTable", "orderId", "order456", "productId", "prod789"); // Select with a filter condition (can use any attribute) await selectItemsWithFilter("UsersTable", "userType", "premium"); // Select items with a prefix (useful for hierarchical data) await selectItemsByPrefix("ProductsTable", "category", "electronics"); // Select items within a range (useful for numeric or date ranges) await selectItemsByRange("OrdersTable", "orderDate", "2023-01-01", "2023-12-31"); };
-
For API details, see the following topics in AWS SDK for JavaScript API Reference.
-
The following code example shows how to query for TTL items.
- SDK for JavaScript (v3)
-
Query Filtered Expression to gather TTL items in a DynamoDB table using AWS SDK for JavaScript.
import { DynamoDBClient, QueryCommand } from "@aws-sdk/client-dynamodb"; import { marshall, unmarshall } from "@aws-sdk/util-dynamodb"; export const queryFiltered = async (tableName, primaryKey, region = 'us-east-1') => { const client = new DynamoDBClient({ region: region, endpoint: `https://dynamodb.${region}.amazonaws.com` }); const currentTime = Math.floor(Date.now() / 1000); const params = { TableName: tableName, KeyConditionExpression: "#pk = :pk", FilterExpression: "#ea > :ea", ExpressionAttributeNames: { "#pk": "primaryKey", "#ea": "expireAt" }, ExpressionAttributeValues: marshall({ ":pk": primaryKey, ":ea": currentTime }) }; try { const { Items } = await client.send(new QueryCommand(params)); Items.forEach(item => { console.log(unmarshall(item)) }); return Items; } catch (err) { console.error(`Error querying items: ${err}`); throw err; } } // Example usage (commented out for testing) // queryFiltered('your-table-name', 'your-partition-key-value');
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to query tables using date and time patterns.
Store and query date/time values in DynamoDB.
Implement date range queries using sort keys.
Format date strings for effective querying.
- SDK for JavaScript (v3)
-
Query using date ranges in sort keys with AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table for items within a specific date range on the sort key * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} partitionKeyName - The name of the partition key * @param {string} partitionKeyValue - The value of the partition key * @param {string} sortKeyName - The name of the sort key (must be a date/time attribute) * @param {Date} startDate - The start date for the range query * @param {Date} endDate - The end date for the range query * @returns {Promise<Object>} - The query response */ async function queryByDateRangeOnSortKey( config, tableName, partitionKeyName, partitionKeyValue, sortKeyName, startDate, endDate ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Format dates as ISO strings for DynamoDB const formattedStartDate = startDate.toISOString(); const formattedEndDate = endDate.toISOString(); // Construct the query input const input = { TableName: tableName, KeyConditionExpression: '#pk = :pkValue AND #sk BETWEEN :startDate AND :endDate', ExpressionAttributeNames: { "#pk": partitionKeyName, "#sk": sortKeyName }, ExpressionAttributeValues: { ":pkValue": { S: partitionKeyValue }, ":startDate": { S: formattedStartDate }, ":endDate": { S: formattedEndDate } } }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying by date range on sort key: ${error}`); throw error; } }
Query using date-time variables with AWS SDK for JavaScript.
const { DynamoDBClient, QueryCommand } = require("@aws-sdk/client-dynamodb"); /** * Queries a DynamoDB table for items within a specific date range * * @param {Object} config - AWS SDK configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} partitionKeyName - The name of the partition key * @param {string} partitionKeyValue - The value of the partition key * @param {string} dateKeyName - The name of the date attribute to filter on * @param {Date} startDate - The start date for the range query * @param {Date} endDate - The end date for the range query * @returns {Promise<Object>} - The query response */ async function queryByDateRange( config, tableName, partitionKeyName, partitionKeyValue, dateKeyName, startDate, endDate ) { try { // Create DynamoDB client const client = new DynamoDBClient(config); // Format dates as ISO strings for DynamoDB const formattedStartDate = startDate.toISOString(); const formattedEndDate = endDate.toISOString(); // Construct the query input const input = { TableName: tableName, KeyConditionExpression: `#pk = :pkValue AND #dateAttr BETWEEN :startDate AND :endDate`, ExpressionAttributeNames: { "#pk": partitionKeyName, "#dateAttr": dateKeyName }, ExpressionAttributeValues: { ":pkValue": { S: partitionKeyValue }, ":startDate": { S: formattedStartDate }, ":endDate": { S: formattedEndDate } } }; // Execute the query const command = new QueryCommand(input); return await client.send(command); } catch (error) { console.error(`Error querying by date range: ${error}`); throw error; } }
-
For API details, see Query in AWS SDK for JavaScript API Reference.
-
The following code example shows how to understand update expression order.
Learn how DynamoDB processes update expressions.
Understand the order of operations in update expressions.
Avoid unexpected results by understanding expression evaluation.
- SDK for JavaScript (v3)
-
Demonstrate update expression order using AWS SDK for JavaScript.
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb"); const { DynamoDBDocumentClient, UpdateCommand, GetCommand, PutCommand } = require("@aws-sdk/lib-dynamodb"); /** * Update an item with multiple actions in a single update expression. * * This function demonstrates how to use multiple actions in a single update expression * and how DynamoDB processes these actions. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The primary key of the item to update * @param {string} updateExpression - The update expression with multiple actions * @param {Object} [expressionAttributeNames] - Expression attribute name placeholders * @param {Object} [expressionAttributeValues] - Expression attribute value placeholders * @returns {Promise<Object>} - The response from DynamoDB */ async function updateWithMultipleActions( config, tableName, key, updateExpression, expressionAttributeNames, expressionAttributeValues ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Prepare the update parameters const updateParams = { TableName: tableName, Key: key, UpdateExpression: updateExpression, ReturnValues: "UPDATED_NEW" }; // Add expression attribute names if provided if (expressionAttributeNames) { updateParams.ExpressionAttributeNames = expressionAttributeNames; } // Add expression attribute values if provided if (expressionAttributeValues) { updateParams.ExpressionAttributeValues = expressionAttributeValues; } // Execute the update const response = await docClient.send(new UpdateCommand(updateParams)); return response; } /** * Demonstrate that variables hold copies of existing values before modifications. * * This function creates an item with initial values, then updates it with an expression * that uses the values of attributes before they are modified in the same expression. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The primary key of the item to create and update * @returns {Promise<Object>} - A dictionary containing the results of the demonstration */ async function demonstrateValueCopying( config, tableName, key ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Step 1: Create an item with initial values const initialItem = { ...key, a: 1, b: 2, c: 3 }; await docClient.send(new PutCommand({ TableName: tableName, Item: initialItem })); // Step 2: Get the item to verify initial state const responseBefore = await docClient.send(new GetCommand({ TableName: tableName, Key: key })); const itemBefore = responseBefore.Item || {}; // Step 3: Update the item with an expression that uses values before they are modified // This expression removes 'a', then sets 'b' to the value of 'a', and 'c' to the value of 'b' const updateResponse = await docClient.send(new UpdateCommand({ TableName: tableName, Key: key, UpdateExpression: "REMOVE a SET b = a, c = b", ReturnValues: "UPDATED_NEW" })); // Step 4: Get the item to verify final state const responseAfter = await docClient.send(new GetCommand({ TableName: tableName, Key: key })); const itemAfter = responseAfter.Item || {}; // Return the results return { initialState: itemBefore, updateResponse: updateResponse, finalState: itemAfter }; } /** * Demonstrate the order in which different action types are processed. * * This function creates an item with initial values, then updates it with an expression * that includes multiple action types (SET, REMOVE, ADD, DELETE) to show the order * in which they are processed. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The primary key of the item to create and update * @returns {Promise<Object>} - A dictionary containing the results of the demonstration */ async function demonstrateActionOrder( config, tableName, key ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Step 1: Create an item with initial values const initialItem = { ...key, counter: 10, set_attr: new Set(["A", "B", "C"]), to_remove: "This will be removed", to_modify: "Original value" }; await docClient.send(new PutCommand({ TableName: tableName, Item: initialItem })); // Step 2: Get the item to verify initial state const responseBefore = await docClient.send(new GetCommand({ TableName: tableName, Key: key })); const itemBefore = responseBefore.Item || {}; // Step 3: Update the item with multiple action types // The actions will be processed in this order: REMOVE, SET, ADD, DELETE const updateResponse = await docClient.send(new UpdateCommand({ TableName: tableName, Key: key, UpdateExpression: "REMOVE to_remove SET to_modify = :new_value ADD counter :increment DELETE set_attr :elements", ExpressionAttributeValues: { ":new_value": "Updated value", ":increment": 5, ":elements": new Set(["B"]) }, ReturnValues: "UPDATED_NEW" })); // Step 4: Get the item to verify final state const responseAfter = await docClient.send(new GetCommand({ TableName: tableName, Key: key })); const itemAfter = responseAfter.Item || {}; // Return the results return { initialState: itemBefore, updateResponse: updateResponse, finalState: itemAfter }; } /** * Update multiple attributes with a single SET action. * * This function demonstrates how to update multiple attributes in a single SET action, * which is more efficient than using multiple separate update operations. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The primary key of the item to update * @param {Object} attributes - The attributes to update and their new values * @returns {Promise<Object>} - The response from DynamoDB */ async function updateWithMultipleSetActions( config, tableName, key, attributes ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Build the update expression and expression attribute values let updateExpression = "SET "; const expressionAttributeValues = {}; // Add each attribute to the update expression Object.entries(attributes).forEach(([attrName, attrValue], index) => { const valuePlaceholder = `:val${index}`; if (index > 0) { updateExpression += ", "; } updateExpression += `${attrName} = ${valuePlaceholder}`; expressionAttributeValues[valuePlaceholder] = attrValue; }); // Execute the update const response = await docClient.send(new UpdateCommand({ TableName: tableName, Key: key, UpdateExpression: updateExpression, ExpressionAttributeValues: expressionAttributeValues, ReturnValues: "UPDATED_NEW" })); return response; } /** * Update an attribute with a value from another attribute or a default value. * * This function demonstrates how to use if_not_exists to conditionally copy a value * from one attribute to another, or use a default value if the source doesn't exist. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The primary key of the item to update * @param {string} sourceAttribute - The attribute to copy the value from * @param {string} targetAttribute - The attribute to update * @param {any} defaultValue - The default value to use if the source attribute doesn't exist * @returns {Promise<Object>} - The response from DynamoDB */ async function updateWithConditionalValueCopying( config, tableName, key, sourceAttribute, targetAttribute, defaultValue ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Use if_not_exists to conditionally copy the value const response = await docClient.send(new UpdateCommand({ TableName: tableName, Key: key, UpdateExpression: `SET ${targetAttribute} = if_not_exists(${sourceAttribute}, :default)`, ExpressionAttributeValues: { ":default": defaultValue }, ReturnValues: "UPDATED_NEW" })); return response; } /** * Demonstrate complex update expressions with multiple operations on the same attribute. * * This function shows how DynamoDB processes multiple operations on the same attribute * in a single update expression. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The primary key of the item to create and update * @returns {Promise<Object>} - A dictionary containing the results of the demonstration */ async function demonstrateMultipleOperationsOnSameAttribute( config, tableName, key ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Step 1: Create an item with initial values const initialItem = { ...key, counter: 10, list_attr: [1, 2, 3], map_attr: { nested1: "value1", nested2: "value2" } }; await docClient.send(new PutCommand({ TableName: tableName, Item: initialItem })); // Step 2: Get the item to verify initial state const responseBefore = await docClient.send(new GetCommand({ TableName: tableName, Key: key })); const itemBefore = responseBefore.Item || {}; // Step 3: Update the item with multiple operations on the same attributes const updateResponse = await docClient.send(new UpdateCommand({ TableName: tableName, Key: key, UpdateExpression: ` SET counter = counter + :inc1, counter = counter + :inc2, map_attr.nested1 = :new_val1, map_attr.nested3 = :new_val3, list_attr[0] = list_attr[1], list_attr[1] = list_attr[2] `, ExpressionAttributeValues: { ":inc1": 5, ":inc2": 3, ":new_val1": "updated_value1", ":new_val3": "new_value3" }, ReturnValues: "UPDATED_NEW" })); // Step 4: Get the item to verify final state const responseAfter = await docClient.send(new GetCommand({ TableName: tableName, Key: key })); const itemAfter = responseAfter.Item || {}; // Return the results return { initialState: itemBefore, updateResponse: updateResponse, finalState: itemAfter }; }
Example usage of update expression order with AWS SDK for JavaScript.
/** * Example of how to use update expression order of operations in DynamoDB. */ async function exampleUsage() { // Example parameters const config = { region: "us-west-2" }; const tableName = "OrderProcessing"; console.log("Demonstrating update expression order of operations in DynamoDB"); try { // Example 1: Demonstrating value copying in update expressions console.log("\nExample 1: Demonstrating value copying in update expressions"); const results1 = await demonstrateValueCopying( config, tableName, { OrderId: "order123" } ); console.log("Initial state:", JSON.stringify(results1.initialState, null, 2)); console.log("Update response:", JSON.stringify(results1.updateResponse, null, 2)); console.log("Final state:", JSON.stringify(results1.finalState, null, 2)); console.log("\nExplanation:"); console.log("1. The initial state had a=1, b=2, c=3"); console.log("2. The update expression 'REMOVE a SET b = a, c = b' did the following:"); console.log(" - Copied the value of 'a' (which was 1) to be used for 'b'"); console.log(" - Copied the value of 'b' (which was 2) to be used for 'c'"); console.log(" - Removed the attribute 'a'"); console.log("3. The final state has b=1, c=2, and 'a' is removed"); console.log("4. This demonstrates that DynamoDB uses the values of attributes as they were BEFORE any modifications"); // Example 2: Demonstrating the order of different action types console.log("\nExample 2: Demonstrating the order of different action types"); const results2 = await demonstrateActionOrder( config, tableName, { OrderId: "order456" } ); console.log("Initial state:", JSON.stringify(results2.initialState, null, 2)); console.log("Update response:", JSON.stringify(results2.updateResponse, null, 2)); console.log("Final state:", JSON.stringify(results2.finalState, null, 2)); console.log("\nExplanation:"); console.log("1. The update expression contained multiple action types: REMOVE, SET, ADD, DELETE"); console.log("2. DynamoDB processes these actions in this order: REMOVE, SET, ADD, DELETE"); console.log("3. First, 'to_remove' was removed"); console.log("4. Then, 'to_modify' was set to a new value"); console.log("5. Next, 'counter' was incremented by 5"); console.log("6. Finally, 'B' was removed from the set attribute"); // Example 3: Updating multiple attributes in a single SET action console.log("\nExample 3: Updating multiple attributes in a single SET action"); const response3 = await updateWithMultipleSetActions( config, tableName, { OrderId: "order789" }, { Status: "Shipped", ShippingDate: "2025-05-28", TrackingNumber: "1Z999AA10123456784" } ); console.log("Multiple attributes updated successfully:", JSON.stringify(response3.Attributes, null, 2)); // Example 4: Conditional value copying with if_not_exists console.log("\nExample 4: Conditional value copying with if_not_exists"); const response4 = await updateWithConditionalValueCopying( config, tableName, { OrderId: "order101" }, "PreferredShippingMethod", "ShippingMethod", "Standard" ); console.log("Conditional value copying result:", JSON.stringify(response4.Attributes, null, 2)); // Example 5: Multiple operations on the same attribute console.log("\nExample 5: Multiple operations on the same attribute"); const results5 = await demonstrateMultipleOperationsOnSameAttribute( config, tableName, { OrderId: "order202" } ); console.log("Initial state:", JSON.stringify(results5.initialState, null, 2)); console.log("Update response:", JSON.stringify(results5.updateResponse, null, 2)); console.log("Final state:", JSON.stringify(results5.finalState, null, 2)); console.log("\nExplanation:"); console.log("1. The counter was incremented twice (first by 5, then by 3) for a total of +8"); console.log("2. The map attribute had one value updated and a new nested attribute added"); console.log("3. The list attribute had values shifted (value at index 1 moved to index 0, value at index 2 moved to index 1)"); console.log("4. All operations within the SET action are processed from left to right"); // Key points about update expression order of operations console.log("\nKey Points About Update Expression Order of Operations:"); console.log("1. Variables in expressions hold copies of attribute values as they existed BEFORE any modifications"); console.log("2. Multiple actions in an update expression are processed in this order: REMOVE, SET, ADD, DELETE"); console.log("3. Within each action type, operations are processed from left to right"); console.log("4. You can reference the same attribute multiple times in an expression"); console.log("5. You can use if_not_exists() to conditionally set values based on attribute existence"); console.log("6. Using a single update expression with multiple actions is more efficient than multiple separate updates"); console.log("7. The update expression is atomic - either all actions succeed or none do"); } catch (error) { console.error("Error:", error); } }
-
For API details, see UpdateItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to update a table's warm throughput setting.
- SDK for JavaScript (v3)
-
Update warm throughput setting on an existing DynamoDB table using AWS SDK for JavaScript.
import { DynamoDBClient, UpdateTableCommand } from "@aws-sdk/client-dynamodb"; export async function updateDynamoDBTableWarmThroughput( tableName, tableReadUnits, tableWriteUnits, gsiName, gsiReadUnits, gsiWriteUnits, region = "us-east-1" ) { try { const ddbClient = new DynamoDBClient({ region: region }); // Construct the update table request const updateTableRequest = { TableName: tableName, GlobalSecondaryIndexUpdates: [ { Update: { IndexName: gsiName, WarmThroughput: { ReadUnitsPerSecond: gsiReadUnits, WriteUnitsPerSecond: gsiWriteUnits, }, }, }, ], WarmThroughput: { ReadUnitsPerSecond: tableReadUnits, WriteUnitsPerSecond: tableWriteUnits, }, }; const command = new UpdateTableCommand(updateTableRequest); const response = await ddbClient.send(command); console.log(`Table updated successfully! Response: ${JSON.stringify(response)}`); return response; } catch (error) { console.error(`Error updating table: ${error}`); throw error; } } // Example usage (commented out for testing) /* updateDynamoDBTableWarmThroughput( 'example-table', 5, 5, 'example-index', 2, 2 ); */
-
For API details, see UpdateTable in AWS SDK for JavaScript API Reference.
-
The following code example shows how to update an item's TTL.
- SDK for JavaScript (v3)
-
import { DynamoDBClient, UpdateItemCommand } from "@aws-sdk/client-dynamodb"; import { marshall, unmarshall } from "@aws-sdk/util-dynamodb"; export const updateItem = async (tableName, partitionKey, sortKey, region = 'us-east-1') => { const client = new DynamoDBClient({ region: region, endpoint: `https://dynamodb.${region}.amazonaws.com` }); const currentTime = Math.floor(Date.now() / 1000); const expireAt = Math.floor((Date.now() + 90 * 24 * 60 * 60 * 1000) / 1000); const params = { TableName: tableName, Key: marshall({ partitionKey: partitionKey, sortKey: sortKey }), UpdateExpression: "SET updatedAt = :c, expireAt = :e", ExpressionAttributeValues: marshall({ ":c": currentTime, ":e": expireAt }), }; try { const data = await client.send(new UpdateItemCommand(params)); const responseData = unmarshall(data.Attributes); console.log("Item updated successfully: %s", responseData); return responseData; } catch (err) { console.error("Error updating item:", err); throw err; } } // Example usage (commented out for testing) // updateItem('your-table-name', 'your-partition-key-value', 'your-sort-key-value');
-
For API details, see UpdateItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to update data using PartiQL UPDATE statements.
- SDK for JavaScript (v3)
-
Update items in a DynamoDB table using PartiQL UPDATE statements with AWS SDK for JavaScript.
/** * This example demonstrates how to update items in a DynamoDB table using PartiQL. * It shows different ways to update documents with various index types. */ import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; import { DynamoDBDocumentClient, ExecuteStatementCommand, BatchExecuteStatementCommand, } from "@aws-sdk/lib-dynamodb"; /** * Update a single attribute of an item using PartiQL. * * @param tableName - The name of the DynamoDB table * @param partitionKeyName - The name of the partition key attribute * @param partitionKeyValue - The value of the partition key * @param attributeName - The name of the attribute to update * @param attributeValue - The new value for the attribute * @returns The response from the ExecuteStatementCommand */ export const updateSingleAttribute = async ( tableName: string, partitionKeyName: string, partitionKeyValue: string | number, attributeName: string, attributeValue: any ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `UPDATE "${tableName}" SET ${attributeName} = ? WHERE ${partitionKeyName} = ?`, Parameters: [attributeValue, partitionKeyValue], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Item updated successfully"); return data; } catch (err) { console.error("Error updating item:", err); throw err; } }; /** * Update multiple attributes of an item using PartiQL. * * @param tableName - The name of the DynamoDB table * @param partitionKeyName - The name of the partition key attribute * @param partitionKeyValue - The value of the partition key * @param attributeUpdates - Object containing attribute names and their new values * @returns The response from the ExecuteStatementCommand */ export const updateMultipleAttributes = async ( tableName: string, partitionKeyName: string, partitionKeyValue: string | number, attributeUpdates: Record<string, any> ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); // Create SET clause for each attribute const setClause = Object.keys(attributeUpdates) .map((attr, index) => `${attr} = ?`) .join(", "); // Create parameters array with attribute values followed by the partition key value const parameters = [...Object.values(attributeUpdates), partitionKeyValue]; const params = { Statement: `UPDATE "${tableName}" SET ${setClause} WHERE ${partitionKeyName} = ?`, Parameters: parameters, }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Item updated successfully"); return data; } catch (err) { console.error("Error updating item:", err); throw err; } }; /** * Update an item identified by a composite key (partition key + sort key) using PartiQL. * * @param tableName - The name of the DynamoDB table * @param partitionKeyName - The name of the partition key attribute * @param partitionKeyValue - The value of the partition key * @param sortKeyName - The name of the sort key attribute * @param sortKeyValue - The value of the sort key * @param attributeName - The name of the attribute to update * @param attributeValue - The new value for the attribute * @returns The response from the ExecuteStatementCommand */ export const updateItemWithCompositeKey = async ( tableName: string, partitionKeyName: string, partitionKeyValue: string | number, sortKeyName: string, sortKeyValue: string | number, attributeName: string, attributeValue: any ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `UPDATE "${tableName}" SET ${attributeName} = ? WHERE ${partitionKeyName} = ? AND ${sortKeyName} = ?`, Parameters: [attributeValue, partitionKeyValue, sortKeyValue], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Item updated successfully"); return data; } catch (err) { console.error("Error updating item:", err); throw err; } }; /** * Update an item with a condition to ensure the update only happens if a condition is met. * * @param tableName - The name of the DynamoDB table * @param partitionKeyName - The name of the partition key attribute * @param partitionKeyValue - The value of the partition key * @param attributeName - The name of the attribute to update * @param attributeValue - The new value for the attribute * @param conditionAttribute - The attribute to check in the condition * @param conditionValue - The value to compare against in the condition * @returns The response from the ExecuteStatementCommand */ export const updateItemWithCondition = async ( tableName: string, partitionKeyName: string, partitionKeyValue: string | number, attributeName: string, attributeValue: any, conditionAttribute: string, conditionValue: any ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); const params = { Statement: `UPDATE "${tableName}" SET ${attributeName} = ? WHERE ${partitionKeyName} = ? AND ${conditionAttribute} = ?`, Parameters: [attributeValue, partitionKeyValue, conditionValue], }; try { const data = await docClient.send(new ExecuteStatementCommand(params)); console.log("Item updated with condition successfully"); return data; } catch (err) { console.error("Error updating item with condition:", err); throw err; } }; /** * Batch update multiple items using PartiQL. * * @param tableName - The name of the DynamoDB table * @param updates - Array of objects containing key and update information * @returns The response from the BatchExecuteStatementCommand */ export const batchUpdateItems = async ( tableName: string, updates: Array<{ partitionKeyName: string; partitionKeyValue: string | number; attributeName: string; attributeValue: any; }> ) => { const client = new DynamoDBClient({}); const docClient = DynamoDBDocumentClient.from(client); // Create statements for each update const statements = updates.map((update) => { return { Statement: `UPDATE "${tableName}" SET ${update.attributeName} = ? WHERE ${update.partitionKeyName} = ?`, Parameters: [update.attributeValue, update.partitionKeyValue], }; }); const params = { Statements: statements, }; try { const data = await docClient.send(new BatchExecuteStatementCommand(params)); console.log("Items batch updated successfully"); return data; } catch (err) { console.error("Error batch updating items:", err); throw err; } }; /** * Example usage showing how to update items with different index types */ export const updateExamples = async () => { // Update a single attribute using a simple primary key await updateSingleAttribute("UsersTable", "userId", "user123", "email", "[email protected]"); // Update multiple attributes at once await updateMultipleAttributes("UsersTable", "userId", "user123", { email: "[email protected]", name: "John Smith", lastLogin: new Date().toISOString(), }); // Update an item with a composite key (partition key + sort key) await updateItemWithCompositeKey( "OrdersTable", "orderId", "order456", "productId", "prod789", "quantity", 5 ); // Update with a condition await updateItemWithCondition( "UsersTable", "userId", "user123", "userStatus", "active", "userType", "premium" ); // Batch update multiple items await batchUpdateItems("UsersTable", [ { partitionKeyName: "userId", partitionKeyValue: "user123", attributeName: "lastLogin", attributeValue: new Date().toISOString(), }, { partitionKeyName: "userId", partitionKeyValue: "user456", attributeName: "lastLogin", attributeValue: new Date().toISOString(), }, ]); };
-
For API details, see the following topics in AWS SDK for JavaScript API Reference.
-
The following code example shows how to create an AWS Lambda function invoked by Amazon API Gateway.
- SDK for JavaScript (v3)
-
Shows how to create an AWS Lambda function by using the Lambda JavaScript runtime API. This example invokes different AWS services to perform a specific use case. This example demonstrates how to create a Lambda function invoked by Amazon API Gateway that scans an Amazon DynamoDB table for work anniversaries and uses Amazon Simple Notification Service (Amazon SNS) to send a text message to your employees that congratulates them at their one year anniversary date.
For complete source code and instructions on how to set up and run, see the full example on GitHub
. This example is also available in the AWS SDK for JavaScript v3 developer guide.
Services used in this example
API Gateway
DynamoDB
Lambda
Amazon SNS
The following code example shows how to use atomic counter operations in DynamoDB.
Increment counters atomically using ADD and SET operations.
Safely increment counters that might not exist.
Implement optimistic locking for counter operations.
- SDK for JavaScript (v3)
-
Demonstrate atomic counter operations using AWS SDK for JavaScript.
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb"); const { DynamoDBDocumentClient, UpdateCommand, GetCommand } = require("@aws-sdk/lib-dynamodb"); /** * Increment a counter using the ADD operation. * * This function demonstrates using the ADD operation for atomic increments. * The ADD operation is atomic and is the recommended way to increment counters. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} counterName - The name of the counter attribute * @param {number} incrementValue - The value to increment by * @returns {Promise<Object>} - The response from DynamoDB */ async function incrementCounterWithAdd( config, tableName, key, counterName, incrementValue ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using ADD const params = { TableName: tableName, Key: key, UpdateExpression: `ADD ${counterName} :increment`, ExpressionAttributeValues: { ":increment": incrementValue }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Increment a counter using the SET operation with an expression. * * This function demonstrates using the SET operation with an expression for increments. * While this approach works, it's less idiomatic for simple increments than using ADD. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} counterName - The name of the counter attribute * @param {number} incrementValue - The value to increment by * @returns {Promise<Object>} - The response from DynamoDB */ async function incrementCounterWithSet( config, tableName, key, counterName, incrementValue ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using SET with an expression const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${counterName} = ${counterName} + :increment`, ExpressionAttributeValues: { ":increment": incrementValue }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Increment a counter safely, handling the case where the counter might not exist. * * This function demonstrates using the if_not_exists function with SET to safely * increment a counter that might not exist yet. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} counterName - The name of the counter attribute * @param {number} incrementValue - The value to increment by * @param {number} defaultValue - The default value if the counter doesn't exist * @returns {Promise<Object>} - The response from DynamoDB */ async function incrementCounterSafely( config, tableName, key, counterName, incrementValue, defaultValue = 0 ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using SET with if_not_exists const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${counterName} = if_not_exists(${counterName}, :default) + :increment`, ExpressionAttributeValues: { ":increment": incrementValue, ":default": defaultValue }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Increment a counter with optimistic locking to prevent race conditions. * * This function demonstrates using a condition expression to implement optimistic * locking, which prevents race conditions when multiple processes try to update * the same counter. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} counterName - The name of the counter attribute * @param {number} incrementValue - The value to increment by * @param {number} expectedValue - The expected current value of the counter * @returns {Promise<Object>} - The response from DynamoDB */ async function incrementCounterWithLocking( config, tableName, key, counterName, incrementValue, expectedValue ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters with a condition expression const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${counterName} = ${counterName} + :increment`, ConditionExpression: `${counterName} = :expected`, ExpressionAttributeValues: { ":increment": incrementValue, ":expected": expectedValue }, ReturnValues: "UPDATED_NEW" }; try { // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return { success: true, data: response }; } catch (error) { // Check if the error is due to the condition check failing if (error.name === "ConditionalCheckFailedException") { return { success: false, error: "Optimistic locking failed: the counter value has changed" }; } // Re-throw other errors throw error; } } /** * Get the current value of a counter. * * Helper function to retrieve the current value of a counter attribute. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to get * @param {string} counterName - The name of the counter attribute * @returns {Promise<number|null>} - The current counter value or null if not found */ async function getCounterValue( config, tableName, key, counterName ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the get parameters const params = { TableName: tableName, Key: key }; // Perform the get operation const response = await docClient.send(new GetCommand(params)); // Return the counter value if it exists, otherwise null return response.Item && counterName in response.Item ? response.Item[counterName] : null; }
Example usage of atomic counter operations with AWS SDK for JavaScript.
/** * Example of how to use the atomic counter operations. */ async function exampleUsage() { // Example parameters const config = { region: "us-west-2" }; const tableName = "Products"; const key = { ProductId: "P12345" }; const counterName = "ViewCount"; const incrementValue = 1; console.log("Demonstrating different approaches to increment counters in DynamoDB"); try { // Example 1: Using ADD operation (recommended for simple increments) console.log("\nExample 1: Incrementing counter with ADD operation"); const response1 = await incrementCounterWithAdd( config, tableName, key, counterName, incrementValue ); console.log(`Counter incremented to: ${response1.Attributes[counterName]}`); // Example 2: Using SET operation with an expression console.log("\nExample 2: Incrementing counter with SET operation"); const response2 = await incrementCounterWithSet( config, tableName, key, counterName, incrementValue ); console.log(`Counter incremented to: ${response2.Attributes[counterName]}`); // Example 3: Safely incrementing a counter that might not exist console.log("\nExample 3: Safely incrementing counter that might not exist"); const newKey = { ProductId: "P67890" }; const response3 = await incrementCounterSafely( config, tableName, newKey, counterName, incrementValue, 0 ); console.log(`Counter initialized and incremented to: ${response3.Attributes[counterName]}`); // Example 4: Incrementing with optimistic locking console.log("\nExample 4: Incrementing with optimistic locking"); // First, get the current counter value const currentValue = await getCounterValue(config, tableName, key, counterName); console.log(`Current counter value: ${currentValue}`); // Then, try to increment with optimistic locking const response4 = await incrementCounterWithLocking( config, tableName, key, counterName, incrementValue, currentValue ); if (response4.success) { console.log(`Counter successfully incremented to: ${response4.data.Attributes[counterName]}`); } else { console.log(response4.error); } // Explain the differences between ADD and SET console.log("\nKey differences between ADD and SET for counter operations:"); console.log("1. ADD is more concise and idiomatic for simple increments"); console.log("2. SET with expressions is more flexible for complex operations"); console.log("3. Both operations are atomic and safe for concurrent updates"); console.log("4. SET with if_not_exists is required when the attribute might not exist"); console.log("5. Optimistic locking can be added to either approach for additional safety"); } catch (error) { console.error("Error:", error); } }
-
For API details, see UpdateItem in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use conditional operations in DynamoDB.
Implement conditional writes to prevent overwriting data.
Use condition expressions to enforce business rules.
Handle conditional check failures gracefully.
- SDK for JavaScript (v3)
-
Demonstrate conditional operations using AWS SDK for JavaScript.
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb"); const { DynamoDBDocumentClient, UpdateCommand, DeleteCommand, GetCommand, PutCommand } = require("@aws-sdk/lib-dynamodb"); /** * Perform a conditional update operation. * * This function demonstrates how to update an item only if a condition is met. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} conditionAttribute - The attribute to check in the condition * @param {any} conditionValue - The value to compare against * @param {string} updateAttribute - The attribute to update * @param {any} updateValue - The new value to set * @returns {Promise<Object>} - Result of the operation */ async function conditionalUpdate( config, tableName, key, conditionAttribute, conditionValue, updateAttribute, updateValue ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters with a condition expression const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${updateAttribute} = :value`, ConditionExpression: `${conditionAttribute} = :condition`, ExpressionAttributeValues: { ":value": updateValue, ":condition": conditionValue }, ReturnValues: "UPDATED_NEW" }; try { // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return { success: true, message: "Condition was met and update was performed", updatedAttributes: response.Attributes }; } catch (error) { // Check if the error is due to the condition check failing if (error.name === "ConditionalCheckFailedException") { return { success: false, message: "Condition was not met, update was not performed", error: "ConditionalCheckFailedException" }; } // Re-throw other errors throw error; } } /** * Perform a conditional delete operation. * * This function demonstrates how to delete an item only if a condition is met. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to delete * @param {string} conditionAttribute - The attribute to check in the condition * @param {any} conditionValue - The value to compare against * @returns {Promise<Object>} - Result of the operation */ async function conditionalDelete( config, tableName, key, conditionAttribute, conditionValue ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the delete parameters with a condition expression const params = { TableName: tableName, Key: key, ConditionExpression: `${conditionAttribute} = :condition`, ExpressionAttributeValues: { ":condition": conditionValue }, ReturnValues: "ALL_OLD" }; try { // Perform the delete operation const response = await docClient.send(new DeleteCommand(params)); return { success: true, message: "Condition was met and item was deleted", deletedItem: response.Attributes }; } catch (error) { // Check if the error is due to the condition check failing if (error.name === "ConditionalCheckFailedException") { return { success: false, message: "Condition was not met, item was not deleted", error: "ConditionalCheckFailedException" }; } // Re-throw other errors throw error; } } /** * Implement optimistic locking with a version number. * * This function demonstrates how to use a version number for optimistic locking * to prevent race conditions when multiple processes update the same item. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {Object} updates - The attributes to update * @param {number} expectedVersion - The expected current version number * @returns {Promise<Object>} - Result of the operation */ async function updateWithOptimisticLocking( config, tableName, key, updates, expectedVersion ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Build the update expression const updateExpressions = []; const expressionAttributeValues = { ":expectedVersion": expectedVersion, ":newVersion": expectedVersion + 1 }; // Add each update to the expression Object.entries(updates).forEach(([attribute, value], index) => { updateExpressions.push(`${attribute} = :val${index}`); expressionAttributeValues[`:val${index}`] = value; }); // Add the version update updateExpressions.push("version = :newVersion"); // Define the update parameters with a condition expression const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${updateExpressions.join(", ")}`, ConditionExpression: "version = :expectedVersion", ExpressionAttributeValues: expressionAttributeValues, ReturnValues: "UPDATED_NEW" }; try { // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return { success: true, message: "Update succeeded with optimistic locking", newVersion: expectedVersion + 1, updatedAttributes: response.Attributes }; } catch (error) { // Check if the error is due to the condition check failing if (error.name === "ConditionalCheckFailedException") { return { success: false, message: "Optimistic locking failed: the item was modified by another process", error: "ConditionalCheckFailedException" }; } // Re-throw other errors throw error; } } /** * Implement a conditional write that creates an item only if it doesn't exist. * * This function demonstrates how to use attribute_not_exists to create an item * only if it doesn't already exist (similar to an "INSERT IF NOT EXISTS" operation). * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} item - The item to create * @returns {Promise<Object>} - Result of the operation */ async function createIfNotExists( config, tableName, item ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Extract the primary key attributes const keyAttributes = Object.keys(item).filter(attr => attr === "id" || attr === "ID" || attr === "Id" || attr.endsWith("Id") || attr.endsWith("ID") || attr.endsWith("Key") ); if (keyAttributes.length === 0) { throw new Error("Could not determine primary key attributes"); } // Create a condition expression that checks if the item doesn't exist const conditionExpression = `attribute_not_exists(${keyAttributes[0]})`; // Define the put parameters with a condition expression const params = { TableName: tableName, Item: item, ConditionExpression: conditionExpression }; try { // Perform the put operation await docClient.send(new PutCommand(params)); return { success: true, message: "Item was created because it didn't exist", item }; } catch (error) { // Check if the error is due to the condition check failing if (error.name === "ConditionalCheckFailedException") { return { success: false, message: "Item already exists, creation was skipped", error: "ConditionalCheckFailedException" }; } // Re-throw other errors throw error; } } /** * Get the current value of an item. * * Helper function to retrieve the current value of an item. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to get * @returns {Promise<Object|null>} - The item or null if not found */ async function getItem( config, tableName, key ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the get parameters const params = { TableName: tableName, Key: key }; // Perform the get operation const response = await docClient.send(new GetCommand(params)); // Return the item if it exists, otherwise null return response.Item || null; }
Example usage of conditional operations with AWS SDK for JavaScript.
/** * Example of how to use conditional operations. */ async function exampleUsage() { // Example parameters const config = { region: "us-west-2" }; const tableName = "Products"; const key = { ProductId: "P12345" }; console.log("Demonstrating conditional operations in DynamoDB"); try { // Example 1: Conditional update based on attribute value console.log("\nExample 1: Conditional update based on attribute value"); const updateResult = await conditionalUpdate( config, tableName, key, "Category", "Electronics", "Price", 299.99 ); console.log(`Result: ${updateResult.message}`); if (updateResult.success) { console.log("Updated attributes:", updateResult.updatedAttributes); } // Example 2: Conditional delete based on attribute value console.log("\nExample 2: Conditional delete based on attribute value"); const deleteResult = await conditionalDelete( config, tableName, key, "InStock", false ); console.log(`Result: ${deleteResult.message}`); if (deleteResult.success) { console.log("Deleted item:", deleteResult.deletedItem); } // Example 3: Optimistic locking with version number console.log("\nExample 3: Optimistic locking with version number"); // First, get the current item to check its version const currentItem = await getItem(config, tableName, { ProductId: "P67890" }); const currentVersion = currentItem ? (currentItem.version || 0) : 0; console.log(`Current version: ${currentVersion}`); // Then, update with optimistic locking const lockingResult = await updateWithOptimisticLocking( config, tableName, { ProductId: "P67890" }, { Name: "Updated Product Name", Description: "This is an updated description" }, currentVersion ); console.log(`Result: ${lockingResult.message}`); if (lockingResult.success) { console.log(`New version: ${lockingResult.newVersion}`); console.log("Updated attributes:", lockingResult.updatedAttributes); } // Example 4: Create item only if it doesn't exist console.log("\nExample 4: Create item only if it doesn't exist"); const createResult = await createIfNotExists( config, tableName, { ProductId: "P99999", Name: "New Product", Category: "Accessories", Price: 19.99, InStock: true } ); console.log(`Result: ${createResult.message}`); if (createResult.success) { console.log("Created item:", createResult.item); } // Explain conditional operations console.log("\nKey points about conditional operations:"); console.log("1. Conditional operations only succeed if the condition is met"); console.log("2. ConditionalCheckFailedException indicates the condition wasn't met"); console.log("3. Optimistic locking prevents race conditions in concurrent updates"); console.log("4. attribute_exists and attribute_not_exists are useful for checking if attributes are present"); console.log("5. Conditional operations are atomic - they either succeed completely or fail completely"); console.log("6. You can use any valid comparison operators and functions in condition expressions"); console.log("7. Conditional operations don't consume write capacity if the condition fails"); } catch (error) { console.error("Error:", error); } }
-
For API details, see the following topics in AWS SDK for JavaScript API Reference.
-
The following code example shows how to use expression attribute names in DynamoDB.
Work with reserved words in DynamoDB expressions.
Use expression attribute name placeholders.
Handle special characters in attribute names.
- SDK for JavaScript (v3)
-
Demonstrate expression attribute names using AWS SDK for JavaScript.
const { DynamoDBClient } = require("@aws-sdk/client-dynamodb"); const { DynamoDBDocumentClient, UpdateCommand, GetCommand, QueryCommand, ScanCommand } = require("@aws-sdk/lib-dynamodb"); /** * Update an attribute that is a reserved word in DynamoDB. * * This function demonstrates how to use expression attribute names to update * attributes that are reserved words in DynamoDB. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} reservedWordAttribute - The reserved word attribute to update * @param {any} value - The value to set * @returns {Promise<Object>} - The response from DynamoDB */ async function updateReservedWordAttribute( config, tableName, key, reservedWordAttribute, value ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using expression attribute names const params = { TableName: tableName, Key: key, UpdateExpression: "SET #attr = :value", ExpressionAttributeNames: { "#attr": reservedWordAttribute }, ExpressionAttributeValues: { ":value": value }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Update an attribute that contains special characters. * * This function demonstrates how to use expression attribute names to update * attributes that contain special characters. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string} specialCharAttribute - The attribute with special characters to update * @param {any} value - The value to set * @returns {Promise<Object>} - The response from DynamoDB */ async function updateSpecialCharacterAttribute( config, tableName, key, specialCharAttribute, value ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the update parameters using expression attribute names const params = { TableName: tableName, Key: key, UpdateExpression: "SET #attr = :value", ExpressionAttributeNames: { "#attr": specialCharAttribute }, ExpressionAttributeValues: { ":value": value }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Query items using an attribute that is a reserved word. * * This function demonstrates how to use expression attribute names in a query * when the attribute is a reserved word. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {string} partitionKeyName - The name of the partition key attribute * @param {any} partitionKeyValue - The value of the partition key * @param {string} reservedWordAttribute - The reserved word attribute to filter on * @param {any} value - The value to compare against * @returns {Promise<Object>} - The response from DynamoDB */ async function queryWithReservedWordAttribute( config, tableName, partitionKeyName, partitionKeyValue, reservedWordAttribute, value ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the query parameters using expression attribute names const params = { TableName: tableName, KeyConditionExpression: "#pkName = :pkValue", FilterExpression: "#attr = :value", ExpressionAttributeNames: { "#pkName": partitionKeyName, "#attr": reservedWordAttribute }, ExpressionAttributeValues: { ":pkValue": partitionKeyValue, ":value": value } }; // Perform the query operation const response = await docClient.send(new QueryCommand(params)); return response; } /** * Update a nested attribute with a path that contains reserved words. * * This function demonstrates how to use expression attribute names to update * nested attributes where the path contains reserved words. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to update * @param {string[]} attributePath - The path to the nested attribute as an array * @param {any} value - The value to set * @returns {Promise<Object>} - The response from DynamoDB */ async function updateNestedReservedWordAttribute( config, tableName, key, attributePath, value ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Create expression attribute names for each part of the path const expressionAttributeNames = {}; for (let i = 0; i < attributePath.length; i++) { expressionAttributeNames[`#attr${i}`] = attributePath[i]; } // Build the attribute path using the expression attribute names const attributePathExpression = attributePath .map((_, i) => `#attr${i}`) .join("."); // Define the update parameters const params = { TableName: tableName, Key: key, UpdateExpression: `SET ${attributePathExpression} = :value`, ExpressionAttributeNames: expressionAttributeNames, ExpressionAttributeValues: { ":value": value }, ReturnValues: "UPDATED_NEW" }; // Perform the update operation const response = await docClient.send(new UpdateCommand(params)); return response; } /** * Scan a table with multiple attribute name placeholders. * * This function demonstrates how to use multiple expression attribute names * in a complex filter expression. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} filters - Object mapping attribute names to filter values * @returns {Promise<Object>} - The response from DynamoDB */ async function scanWithMultipleAttributeNames( config, tableName, filters ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Create expression attribute names and values const expressionAttributeNames = {}; const expressionAttributeValues = {}; const filterConditions = []; // Build the filter expression Object.entries(filters).forEach(([attrName, value], index) => { const nameKey = `#attr${index}`; const valueKey = `:val${index}`; expressionAttributeNames[nameKey] = attrName; expressionAttributeValues[valueKey] = value; filterConditions.push(`${nameKey} = ${valueKey}`); }); // Join the filter conditions with AND const filterExpression = filterConditions.join(" AND "); // Define the scan parameters const params = { TableName: tableName, FilterExpression: filterExpression, ExpressionAttributeNames: expressionAttributeNames, ExpressionAttributeValues: expressionAttributeValues }; // Perform the scan operation const response = await docClient.send(new ScanCommand(params)); return response; } /** * Get the current value of an item. * * Helper function to retrieve the current value of an item. * * @param {Object} config - AWS configuration object * @param {string} tableName - The name of the DynamoDB table * @param {Object} key - The key of the item to get * @returns {Promise<Object|null>} - The item or null if not found */ async function getItem( config, tableName, key ) { // Initialize the DynamoDB client const client = new DynamoDBClient(config); const docClient = DynamoDBDocumentClient.from(client); // Define the get parameters const params = { TableName: tableName, Key: key }; // Perform the get operation const response = await docClient.send(new GetCommand(params)); // Return the item if it exists, otherwise null return response.Item || null; }
Example usage of expression attribute names with AWS SDK for JavaScript.
/** * Example of how to use expression attribute names. */ async function exampleUsage() { // Example parameters const config = { region: "us-west-2" }; const tableName = "Products"; const key = { ProductId: "P12345" }; console.log("Demonstrating expression attribute names in DynamoDB"); try { // Example 1: Update an attribute that is a reserved word console.log("\nExample 1: Updating an attribute that is a reserved word"); const response1 = await updateReservedWordAttribute( config, tableName, key, "Size", // "SIZE" is a reserved word in DynamoDB "Large" ); console.log("Updated attribute:", response1.Attributes); // Example 2: Update an attribute with special characters console.log("\nExample 2: Updating an attribute with special characters"); const response2 = await updateSpecialCharacterAttribute( config, tableName, key, "Product-Type", // Contains a hyphen, which is a special character "Electronics" ); console.log("Updated attribute:", response2.Attributes); // Example 3: Query with a reserved word attribute console.log("\nExample 3: Querying with a reserved word attribute"); const response3 = await queryWithReservedWordAttribute( config, tableName, "Category", "Electronics", "Count", // "COUNT" is a reserved word in DynamoDB 10 ); console.log(`Found ${response3.Items.length} items`); // Example 4: Update a nested attribute with reserved words in the path console.log("\nExample 4: Updating a nested attribute with reserved words in the path"); const response4 = await updateNestedReservedWordAttribute( config, tableName, key, ["Dimensions", "Size", "Height"], // "SIZE" is a reserved word 30 ); console.log("Updated nested attribute:", response4.Attributes); // Example 5: Scan with multiple attribute name placeholders console.log("\nExample 5: Scanning with multiple attribute name placeholders"); const response5 = await scanWithMultipleAttributeNames( config, tableName, { "Size": "Large", "Count": 10, "Product-Type": "Electronics" } ); console.log(`Found ${response5.Items.length} items`); // Get the final state of the item console.log("\nFinal state of the item:"); const item = await getItem(config, tableName, key); console.log(JSON.stringify(item, null, 2)); // Show some common reserved words console.log("\nSome common DynamoDB reserved words:"); const commonReservedWords = [ "ABORT", "ABSOLUTE", "ACTION", "ADD", "ALL", "ALTER", "AND", "ANY", "AS", "ASC", "BETWEEN", "BY", "CASE", "CAST", "COLUMN", "CONNECT", "COUNT", "CREATE", "CURRENT", "DATE", "DELETE", "DESC", "DROP", "ELSE", "EXISTS", "FOR", "FROM", "GRANT", "GROUP", "HAVING", "IN", "INDEX", "INSERT", "INTO", "IS", "JOIN", "KEY", "LEVEL", "LIKE", "LIMIT", "LOCAL", "MAX", "MIN", "NAME", "NOT", "NULL", "OF", "ON", "OR", "ORDER", "OUTER", "REPLACE", "RETURN", "SELECT", "SET", "SIZE", "TABLE", "THEN", "TO", "UPDATE", "USER", "VALUES", "VIEW", "WHERE" ]; console.log(commonReservedWords.join(", ")); // Explain expression attribute names console.log("\nKey points about expression attribute names:"); console.log("1. Use expression attribute names (#name) for reserved words"); console.log("2. Use expression attribute names for attributes with special characters"); console.log("3. Special characters include: spaces, hyphens, dots, and other non-alphanumeric characters"); console.log("4. Expression attribute names are required for nested attributes with reserved words"); console.log("5. You can use multiple expression attribute names in a single expression"); console.log("6. Expression attribute names are case-sensitive"); console.log("7. Expression attribute names are only used in expressions, not in the actual data"); } catch (error) { console.error("Error:", error); } }
-
For API details, see the following topics in AWS SDK for JavaScript API Reference.
-
The following code example shows how to create an AWS Lambda function invoked by an Amazon EventBridge scheduled event.
- SDK for JavaScript (v3)
-
Shows how to create an Amazon EventBridge scheduled event that invokes an AWS Lambda function. Configure EventBridge to use a cron expression to schedule when the Lambda function is invoked. In this example, you create a Lambda function by using the Lambda JavaScript runtime API. This example invokes different AWS services to perform a specific use case. This example demonstrates how to create an app that sends a mobile text message to your employees that congratulates them at the one year anniversary date.
For complete source code and instructions on how to set up and run, see the full example on GitHub
. This example is also available in the AWS SDK for JavaScript v3 developer guide.
Services used in this example
CloudWatch Logs
DynamoDB
EventBridge
Lambda
Amazon SNS
Serverless examples
The following code example shows how to implement a Lambda function that receives an event triggered by receiving records from a DynamoDB stream. The function retrieves the DynamoDB payload and logs the record contents.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the Serverless examples
repository. Consuming a DynamoDB event with Lambda using JavaScript.
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. // SPDX-License-Identifier: Apache-2.0 exports.handler = async (event, context) => { console.log(JSON.stringify(event, null, 2)); event.Records.forEach(record => { logDynamoDBRecord(record); }); }; const logDynamoDBRecord = (record) => { console.log(record.eventID); console.log(record.eventName); console.log(`DynamoDB Record: ${JSON.stringify(record.dynamodb)}`); };
Consuming a DynamoDB event with Lambda using TypeScript.
export const handler = async (event, context) => { console.log(JSON.stringify(event, null, 2)); event.Records.forEach(record => { logDynamoDBRecord(record); }); } const logDynamoDBRecord = (record) => { console.log(record.eventID); console.log(record.eventName); console.log(`DynamoDB Record: ${JSON.stringify(record.dynamodb)}`); };
The following code example shows how to implement partial batch response for Lambda functions that receive events from a DynamoDB stream. The function reports the batch item failures in the response, signaling to Lambda to retry those messages later.
- SDK for JavaScript (v3)
-
Note
There's more on GitHub. Find the complete example and learn how to set up and run in the Serverless examples
repository. Reporting DynamoDB batch item failures with Lambda using JavaScript.
export const handler = async (event) => { const records = event.Records; let curRecordSequenceNumber = ""; for (const record of records) { try { // Process your record curRecordSequenceNumber = record.dynamodb.SequenceNumber; } catch (e) { // Return failed record's sequence number return { batchItemFailures: [{ itemIdentifier: curRecordSequenceNumber }] }; } } return { batchItemFailures: [] }; };
Reporting DynamoDB batch item failures with Lambda using TypeScript.
import { DynamoDBBatchResponse, DynamoDBBatchItemFailure, DynamoDBStreamEvent, } from "aws-lambda"; export const handler = async ( event: DynamoDBStreamEvent ): Promise<DynamoDBBatchResponse> => { const batchItemFailures: DynamoDBBatchItemFailure[] = []; let curRecordSequenceNumber; for (const record of event.Records) { curRecordSequenceNumber = record.dynamodb?.SequenceNumber; if (curRecordSequenceNumber) { batchItemFailures.push({ itemIdentifier: curRecordSequenceNumber, }); } } return { batchItemFailures: batchItemFailures }; };