Sono disponibili altri esempi AWS SDK nel repository AWS Doc SDK
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
Esempi di DynamoDB che utilizzano SDK JavaScript for (v3)
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS SDK per JavaScript (v3) con DynamoDB.
Le nozioni di base sono esempi di codice che mostrano come eseguire le operazioni essenziali all'interno di un servizio.
Le operazioni sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le operazioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Gli scenari sono esempi di codice che mostrano come eseguire un'attività specifica richiamando più funzioni all'interno dello stesso servizio o combinate con altri Servizi AWS.
Ogni esempio include un collegamento al codice sorgente completo, dove è possibile trovare istruzioni su come configurare ed eseguire il codice nel contesto.
Nozioni di base
Gli esempi di codice seguenti mostrano come iniziare a utilizzare DynamoDB.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Per maggiori dettagli sull'utilizzo di DynamoDB AWS SDK per JavaScript in, consulta Programmazione di DynamoDB con. 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; };
-
Per i dettagli sulle API, consulta ListTablesla sezione API Reference.AWS SDK per JavaScript
-
Nozioni di base
L'esempio di codice seguente mostra come:
Crea una tabella in grado di contenere i dati del filmato.
Inserisci, ottieni e aggiorna un singolo filmato nella tabella.
Scrivi i dati del filmato nella tabella da un file JSON di esempio.
Esegui una query sui filmati che sono stati rilasciati in un dato anno.
Cerca i filmati che sono stati distribuiti in diversi anni.
Elimina un filmato dalla tabella, quindi elimina la tabella.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. 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."); };
-
Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Azioni
Il seguente esempio di codice mostra come usareBatchExecuteStatement
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Creazione di un batch di elementi mediante 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; };
Ottenimento di un batch di elementi mediante 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; };
Aggiornamento di un batch di elementi mediante 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; };
Eliminazione di un batch di elementi mediante 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; };
-
Per i dettagli sull'API, consulta la BatchExecuteStatementsezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzareBatchGetItem
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Questo esempio utilizza il client di documenti per semplificare il lavoro con gli elementi in DynamoDB. Per i dettagli sull'API, vedi 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; };
-
Per ulteriori informazioni, consulta la Guida per sviluppatori di AWS SDK per JavaScript.
-
Per i dettagli sulle API, consulta la BatchGetItemsezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzareBatchWriteItem
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Questo esempio utilizza il client di documenti per semplificare il lavoro con gli elementi in DynamoDB. Per i dettagli sull'API, vedi 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); } };
-
Per i dettagli sulle API, consulta la BatchWriteItemsezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzareCreateTable
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. 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; };
-
Per ulteriori informazioni, consulta la Guida per sviluppatori di AWS SDK per JavaScript.
-
Per i dettagli sull'API, consulta la CreateTablesezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzareDeleteItem
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Questo esempio utilizza il client di documenti per semplificare il lavoro con gli elementi in DynamoDB. Per i dettagli sull'API, vedi 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; };
-
Per ulteriori informazioni, consulta la Guida per sviluppatori di AWS SDK per JavaScript.
-
Per i dettagli sulle API, consulta la DeleteItemsezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzareDeleteTable
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. 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; };
-
Per i dettagli sull'API, consulta la DeleteTablesezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzareDescribeTable
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. 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; };
-
Per ulteriori informazioni, consulta la Guida per sviluppatori di AWS SDK per JavaScript.
-
Per i dettagli sull'API, consulta la DescribeTablesezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzareDescribeTimeToLive
.
- SDK per JavaScript (v3)
-
Descrivi la configurazione TTL su una tabella DynamoDB esistente utilizzando. AWS SDK per 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');
-
Per i dettagli sull'API, consulta la sezione API DescribeTimeToLiveReference AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come utilizzareExecuteStatement
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Creazione di un elemento mediante 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; };
Ottenimento di un elemento mediante 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; };
Aggiornamento di un elemento mediante 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; };
Eliminazione di un elemento mediante 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; };
-
Per i dettagli sull'API, consulta la ExecuteStatementsezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzareGetItem
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Questo esempio utilizza il client di documenti per semplificare il lavoro con gli elementi in DynamoDB. Per i dettagli sull'API, vedi 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; };
-
Per i dettagli sulle API, consulta la GetItemsezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzareListTables
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. 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; };
-
Per ulteriori informazioni, consulta la Guida per sviluppatori di AWS SDK per JavaScript.
-
Per i dettagli sull'API, consulta la ListTablessezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzarePutItem
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Questo esempio utilizza il client di documenti per semplificare il lavoro con gli elementi in DynamoDB. Per i dettagli sull'API, vedi 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; };
-
Per i dettagli sulle API, consulta la PutItemsezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzareQuery
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Questo esempio utilizza il client di documenti per semplificare il lavoro con gli elementi in DynamoDB. Per i dettagli sull'API, vedi 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; };
-
Per ulteriori informazioni, consulta la Guida per sviluppatori di AWS SDK per JavaScript.
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come utilizzareScan
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Questo esempio utilizza il client di documenti per semplificare il lavoro con gli elementi in DynamoDB. Per i dettagli sull'API, vedi 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; };
-
Per informazioni dettagliate sulle API, consulta Scan nella Documentazione di riferimento per le API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come utilizzareUpdateItem
.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Questo esempio utilizza il client di documenti per semplificare il lavoro con gli elementi in DynamoDB. Per i dettagli sull'API, vedi 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; };
-
Per i dettagli sulle API, consulta la UpdateItemsezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come utilizzareUpdateTimeToLive
.
- SDK per JavaScript (v3)
-
Abilita TTL su una tabella DynamoDB esistente.
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');
Disabilita il TTL su una tabella DynamoDB esistente.
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');
-
Per i dettagli sull'API, consulta la sezione API UpdateTimeToLiveReference AWS SDK per JavaScript .
-
Scenari
Il seguente esempio di codice mostra come creare un'applicazione che invia dati a una tabella Amazon DynamoDB e ti avvisa quando un utente aggiorna la tabella.
- SDK per (v3) JavaScript
-
Questo esempio mostra come creare un'app che consenta agli utenti di inviare dati a una tabella Amazon DynamoDB e un messaggio di testo all'amministratore utilizzando Amazon Simple Notification Service (Amazon SNS).
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su. GitHub
Questo esempio è anche disponibile nella Guida per lo sviluppatore di AWS SDK per JavaScript v3 .
Servizi utilizzati in questo esempio
DynamoDB
Amazon SNS
Il seguente esempio di codice mostra come confrontare più valori con un singolo attributo in DynamoDB.
Utilizzate l'operatore IN per confrontare più valori con un singolo attributo.
Confronta l'operatore IN con più condizioni OR.
Comprendi i vantaggi in termini di prestazioni e complessità di espressione derivanti dall'utilizzo di IN.
- SDK per JavaScript (v3)
-
Confronta più valori con un singolo attributo utilizzando. AWS SDK per 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 }; } }
Esempio di utilizzo del confronto di più valori con AWS SDK per 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); } }
Il seguente esempio di codice mostra come aggiornare in modo condizionale il TTL di un elemento.
- SDK per (v3 JavaScript )
-
Aggiorna il TTL su un elemento DynamoDB esistente in una tabella, con una condizione.
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');
-
Per i dettagli sull'API, consulta la sezione API UpdateItemReference AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come contare gli operatori di espressione in DynamoDB.
Comprendi il limite di 300 operatori di DynamoDB.
Conta gli operatori nelle espressioni complesse.
Ottimizza le espressioni per rimanere entro i limiti.
- SDK per JavaScript (v3)
-
Dimostra il conteggio degli operatori di espressioni utilizzando. AWS SDK per 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; }
Esempio di utilizzo dell'operatore di espressione che conta con. AWS SDK per 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); } }
-
Per i dettagli sull'API, consulta la sezione UpdateItem AWS SDK per JavaScriptAPI Reference.
-
Nell'esempio di codice seguente viene illustrato come creare un'applicazione serverless che consente agli utenti di gestire le foto mediante etichette.
- SDK per JavaScript (v3)
-
Mostra come sviluppare un'applicazione per la gestione delle risorse fotografiche che rileva le etichette nelle immagini utilizzando Amazon Rekognition e le archivia per recuperarle in seguito.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su. GitHub
Per approfondire l'origine di questo esempio, consulta il post su AWS Community
. Servizi utilizzati in questo esempio
API Gateway
DynamoDB
Lambda
Amazon Rekognition
Amazon S3
Amazon SNS
Il seguente esempio di codice mostra come creare una tabella con la velocità effettiva calda abilitata.
- SDK per JavaScript (v3)
-
Crea una tabella DynamoDB con l'impostazione della velocità effettiva calda utilizzando. AWS SDK per 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 ); */
-
Per i dettagli sull'API, consulta la sezione API CreateTableReference AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come creare un elemento con TTL.
- SDK per 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');
-
Per i dettagli sull'API, consulta la sezione AWS SDK per JavaScript API PutItemReference.
-
Il seguente esempio di codice mostra come eliminare i dati utilizzando le istruzioni PartiQL DELETE.
- SDK per JavaScript (v3)
-
Eliminare elementi da una tabella DynamoDB utilizzando le istruzioni PartiQL DELETE con. AWS SDK per 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"); };
-
Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come inserire dati utilizzando le istruzioni PartiQL INSERT.
- SDK per JavaScript (v3)
-
Inserisci elementi in una tabella DynamoDB utilizzando le istruzioni PartiQL INSERT con. AWS SDK per 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: "john@example.com", }; 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: "jane@example.com", 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: "alice@example.com", }, { userId: "user345", name: "Bob Williams", email: "bob@example.com", }, ]; await batchInsertItems("UsersTable", batchItems); };
-
Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come richiamare una AWS Lambda funzione da un browser.
- SDK per JavaScript (v3)
-
Puoi creare un'applicazione basata su browser che utilizza una AWS Lambda funzione per aggiornare una tabella Amazon DynamoDB con selezioni utente. Questa app utilizza la versione 3. AWS SDK per JavaScript
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su GitHub
. Servizi utilizzati in questo esempio
DynamoDB
Lambda
Il seguente esempio di codice mostra come eseguire operazioni di interrogazione avanzate in DynamoDB.
Tabelle di interrogazione che utilizzano varie tecniche di filtraggio e condizione.
Implementa l'impaginazione per set di risultati di grandi dimensioni.
Usa gli indici secondari globali per modelli di accesso alternativi.
Applica controlli di coerenza in base ai requisiti dell'applicazione.
- SDK per JavaScript (v3)
-
Interroga con letture fortemente coerenti utilizzando. AWS SDK per 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; } }
Esegui una query utilizzando un indice secondario globale con AWS SDK per 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; } }
Interrogazione con impaginazione utilizzando AWS SDK per 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 };
Interrogazione con filtri complessi utilizzando AWS SDK per 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; } }
Interrogazione con un'espressione di filtro costruita dinamicamente utilizzando AWS SDK per 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; } }
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come eseguire operazioni sugli elenchi in DynamoDB.
Aggiungere elementi a un attributo di elenco.
Rimuove elementi da un attributo di elenco.
Aggiorna elementi specifici in un elenco per indice.
Usa le funzioni di aggiunta alla lista e all'indice delle liste.
- SDK per JavaScript (v3)
-
Dimostra le operazioni sugli elenchi utilizzando. AWS SDK per 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; }
Esempio di utilizzo delle operazioni di elenco con AWS SDK per 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; }
-
Per i dettagli sull'API, vedere UpdateItemin AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come eseguire operazioni di mappatura in DynamoDB.
Aggiungi e aggiorna gli attributi annidati nelle strutture della mappa.
Rimuovi campi specifici dalle mappe.
Lavora con attributi di mappa profondamente annidati.
- SDK per JavaScript (v3)
-
Dimostra le operazioni sulla mappa utilizzando. AWS SDK per 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: "user@example.com", 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(); }
-
Per i dettagli sull'API, consulta la UpdateItemsezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come eseguire operazioni di set in DynamoDB.
Aggiungere elementi a un attributo set.
Rimuove elementi da un attributo set.
Usa le operazioni ADD e DELETE con i set.
- SDK per JavaScript (v3)
-
Dimostra le operazioni sul set utilizzando. AWS SDK per 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; }
Esempio di utilizzo delle operazioni di set con AWS SDK per 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); } }
-
Per i dettagli sull'API, vedere UpdateItemin AWS SDK per JavaScript API Reference.
-
L'esempio di codice seguente mostra come:
Ricezione di un batch di elementi mediante più istruzioni SELECT.
Aggiunta di un batch di articoli eseguendo più istruzioni INSERT.
Aggiornamento di un batch di elementi mediante più istruzioni UPDATE.
Eliminazione di un batch di elementi mediante più istruzioni DELETE.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Eseguire le istruzioni PartiQL in batch.
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."); };
-
Per i dettagli sull'API, consulta la BatchExecuteStatementsezione AWS SDK per JavaScript API Reference.
-
L'esempio di codice seguente mostra come:
Ricezione di un articolo eseguendo un'istruzione SELECT.
Aggiunta di un elemento eseguendo un'istruzione INSERT.
Aggiornamento di un elemento eseguendo un'istruzione UPDATE.
Eliminazione di un elemento eseguendo un'istruzione DELETE.
- SDK per JavaScript (v3)
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS
. Eseguire le singole istruzioni PartiQL.
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."); };
-
Per i dettagli sull'API, consulta la ExecuteStatementsezione AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come eseguire una query su una tabella utilizzando un indice secondario globale.
Interroga una tabella DynamoDB utilizzando la sua chiave primaria.
Interroga un Global Secondary Index (GSI) per modelli di accesso alternativi.
Confronta le query relative alle tabelle e le interrogazioni GSI.
- SDK per (v3) JavaScript
-
Interroga una tabella DynamoDB utilizzando la chiave primaria con. AWS SDK per 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; } }
Interroga un DynamoDB Global Secondary Index (GSI) con. AWS SDK per 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; } }
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come interrogare una tabella utilizzando una condizione begins_with.
Utilizzate la funzione begins_with in un'espressione di condizione chiave.
Filtra gli elementi in base a uno schema di prefisso nella chiave di ordinamento.
- SDK per JavaScript (v3)
-
Interroga una tabella DynamoDB utilizzando una condizione begins_with sulla chiave di ordinamento con. AWS SDK per 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; } }
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come eseguire una query su una tabella utilizzando un intervallo di date nella chiave di ordinamento.
Interroga gli elementi all'interno di un intervallo di date specifico.
Utilizza gli operatori di confronto sulle chiavi di ordinamento in formato data.
- SDK per (v3) JavaScript
-
Interroga una tabella DynamoDB per gli elementi compresi in un intervallo di date con. AWS SDK per 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; } }
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come eseguire una query su una tabella con un'espressione di filtro complessa.
Applica espressioni di filtro complesse ai risultati delle query.
Combina più condizioni utilizzando operatori logici.
Filtra gli elementi in base ad attributi non chiave.
- SDK per JavaScript (v3)
-
Interroga una tabella DynamoDB con un'espressione di filtro complessa utilizzando. AWS SDK per 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; } }
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come eseguire una query su una tabella con un'espressione di filtro dinamica.
Crea espressioni di filtro in modo dinamico in fase di esecuzione.
Crea condizioni di filtro in base all'input dell'utente o allo stato dell'applicazione.
Aggiungi o rimuovi i criteri di filtro in modo condizionale.
- SDK per JavaScript (v3)
-
Interroga una tabella DynamoDB con un'espressione di filtro costruita dinamicamente utilizzando. AWS SDK per 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; } }
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come interrogare una tabella con attributi annidati.
Accedi e filtra per attributi annidati negli elementi DynamoDB.
Utilizza le espressioni del percorso del documento per fare riferimento agli elementi nidificati.
- SDK per JavaScript (v3)
-
Interroga una tabella DynamoDB con attributi annidati utilizzando. AWS SDK per 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; } }
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come interrogare una tabella con impaginazione.
Implementa la paginazione per i risultati delle query DynamoDB.
Utilizzate il LastEvaluatedKey per recuperare le pagine successive.
Controlla il numero di elementi per pagina con il parametro Limit.
- SDK per JavaScript (v3)
-
Interroga una tabella DynamoDB con impaginazione utilizzando. AWS SDK per 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 };
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come interrogare una tabella con letture fortemente coerenti.
Configura il livello di coerenza per le query DynamoDB.
Utilizza letture fortemente coerenti per ottenere la maggior parte dei dati. up-to-date
Comprendi i compromessi tra coerenza finale e forte coerenza.
- SDK per (v3) JavaScript
-
Interroga una tabella DynamoDB con coerenza di lettura configurabile utilizzando. AWS SDK per 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; } }
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come interrogare i dati utilizzando le istruzioni PartiQL SELECT.
- SDK per JavaScript (v3)
-
Interroga gli elementi da una tabella DynamoDB utilizzando le istruzioni PartiQL SELECT con. AWS SDK per 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"); };
-
Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come eseguire una query per gli elementi TTL.
- SDK per JavaScript (v3)
-
Interroga l'espressione filtrata per raccogliere elementi TTL in una tabella DynamoDB utilizzando. AWS SDK per 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');
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come interrogare le tabelle utilizzando modelli di data e ora.
Archivia e interroga i valori di data/ora in DynamoDB.
Implementa interrogazioni su intervalli di date utilizzando chiavi di ordinamento.
Formatta le stringhe di data per un'interrogazione efficace.
- SDK per (v3 JavaScript )
-
Esegui una query utilizzando intervalli di date nelle chiavi di ordinamento con. AWS SDK per 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; } }
Interroga utilizzando variabili data-ora con. AWS SDK per 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; } }
-
Per ulteriori informazioni sulle API, consulta Query nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come comprendere l'ordine delle espressioni di aggiornamento.
Scopri come DynamoDB elabora le espressioni di aggiornamento.
Comprendi l'ordine delle operazioni nelle espressioni di aggiornamento.
Evita risultati imprevisti comprendendo la valutazione delle espressioni.
- SDK per JavaScript (v3)
-
Dimostra l'ordine di aggiornamento delle espressioni utilizzando. AWS SDK per 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 }; }
Esempio di utilizzo dell'ordine di aggiornamento delle espressioni con AWS SDK per 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); } }
-
Per i dettagli sull'API, vedere UpdateItemin AWS SDK per JavaScript API Reference.
-
Il seguente esempio di codice mostra come aggiornare l'impostazione del throughput caldo di una tabella.
- SDK per JavaScript (v3)
-
Aggiorna l'impostazione del throughput caldo su una tabella DynamoDB esistente utilizzando. AWS SDK per 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 ); */
-
Per i dettagli sull'API, consulta la sezione API UpdateTableReference AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come aggiornare il TTL di un elemento.
- SDK per 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');
-
Per i dettagli sull'API, consulta la sezione AWS SDK per JavaScript API UpdateItemReference.
-
Il seguente esempio di codice mostra come aggiornare i dati utilizzando le istruzioni PartiQL UPDATE.
- SDK per JavaScript (v3)
-
Aggiorna gli elementi in una tabella DynamoDB utilizzando le istruzioni PartiQL UPDATE con. AWS SDK per 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", "newemail@example.com"); // Update multiple attributes at once await updateMultipleAttributes("UsersTable", "userId", "user123", { email: "newemail@example.com", 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(), }, ]); };
-
Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come creare una AWS Lambda funzione richiamata da Amazon API Gateway.
- SDK per JavaScript (v3)
-
Mostra come creare una AWS Lambda funzione utilizzando l'API di JavaScript runtime Lambda. Questo esempio richiama diversi AWS servizi per eseguire un caso d'uso specifico. In questo esempio viene illustrato come creare una funzione Lambda richiamata da Gateway Amazon API che analizza una tabella Amazon DynamoDB per le ricorrenze di lavoro e utilizza Amazon Simple Notification Service (Amazon SNS) per inviare un messaggio di testo ai dipendenti che si congratula con loro alla data dell'anniversario di un anno.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su. GitHub
Questo esempio è anche disponibile nella Guida per lo sviluppatore di AWS SDK per JavaScript v3 .
Servizi utilizzati in questo esempio
API Gateway
DynamoDB
Lambda
Amazon SNS
Il seguente esempio di codice mostra come utilizzare le operazioni del contatore atomico in DynamoDB.
Incrementa i contatori atomicamente utilizzando le operazioni ADD e SET.
Incrementa in modo sicuro i contatori che potrebbero non esistere.
Implementa un blocco ottimistico per le operazioni di sportello.
- SDK per (v3 JavaScript )
-
Dimostra le controoperazioni atomiche utilizzando. AWS SDK per 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; }
Esempio di utilizzo delle operazioni di conteggio atomico con. AWS SDK per 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); } }
-
Per i dettagli sull'API, consulta la sezione UpdateItem AWS SDK per JavaScriptAPI Reference.
-
Il seguente esempio di codice mostra come utilizzare le operazioni condizionali in DynamoDB.
Implementa scritture condizionali per evitare la sovrascrittura dei dati.
Utilizza le espressioni condizionali per applicare le regole aziendali.
Gestisci con garbo gli errori dei controlli condizionali.
- SDK per (v3) JavaScript
-
Dimostra le operazioni condizionali utilizzando. AWS SDK per 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; }
Esempio di utilizzo di operazioni condizionali con. AWS SDK per 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); } }
-
Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come utilizzare i nomi degli attributi di espressione in DynamoDB.
Lavora con parole riservate nelle espressioni DynamoDB.
Usa i segnaposto per i nomi degli attributi di espressione.
Gestisci i caratteri speciali nei nomi degli attributi.
- SDK per JavaScript (v3)
-
Dimostra i nomi degli attributi di espressione utilizzando. AWS SDK per 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; }
Esempio di utilizzo dei nomi degli attributi di espressione con AWS SDK per 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); } }
-
Per informazioni dettagliate sull'API, consulta i seguenti argomenti nella Documentazione di riferimento delle API AWS SDK per JavaScript .
-
Il seguente esempio di codice mostra come creare una AWS Lambda funzione richiamata da un evento EventBridge pianificato di Amazon.
- SDK per JavaScript (v3)
-
Mostra come creare un evento EventBridge pianificato da Amazon che richiami una AWS Lambda funzione. Configura EventBridge per utilizzare un'espressione cron per pianificare quando viene richiamata la funzione Lambda. In questo esempio, crei una funzione Lambda utilizzando l'API JavaScript Lambda runtime. Questo esempio richiama diversi AWS servizi per eseguire un caso d'uso specifico. Questo esempio dimostra come creare un'app che invia un messaggio di testo via mobile ai tuoi dipendenti che si congratula con loro alla data dell'anniversario di un anno.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su. GitHub
Questo esempio è anche disponibile nella Guida per lo sviluppatore di AWS SDK per JavaScript v3 .
Servizi utilizzati in questo esempio
CloudWatch Registri
DynamoDB
EventBridge
Lambda
Amazon SNS
Esempi serverless
Il seguente esempio di codice mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di record da un flusso DynamoDB. La funzione recupera il payload DocumentDB e registra il contenuto del record.
- SDK per (v3) JavaScript
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di Esempi serverless
. Consumo di un evento DynamoDB con Lambda utilizzando. 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)}`); };
Consumo di un evento DynamoDB con Lambda utilizzando. 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)}`); };
Il seguente esempio di codice mostra come implementare una risposta batch parziale per le funzioni Lambda che ricevono eventi da un flusso DynamoDB. La funzione riporta gli errori degli elementi batch nella risposta, segnalando a Lambda di riprovare tali messaggi in un secondo momento.
- SDK per (v3) JavaScript
-
Nota
C'è altro da fare. GitHub Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di Esempi serverless
. Segnalazione degli errori degli elementi batch di DynamoDB utilizzando Lambda. 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: [] }; };
Segnalazione degli errori degli elementi batch di DynamoDB utilizzando Lambda. 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 }; };