DynamoDB Data Modeling & Operations

1{
2  "userId": "usr_01J8X",
3  "email": "alice@example.com",
4  "createdAt": "2024-01-15T10:30:00Z",
5  "profile": {
6    "name": "Alice Johnson",
7    "tier": "premium"
8  },
9  "tags": ["admin", "beta-tester"]
10}

1aws dynamodb create-table \
2  --table-name Orders \
3  --attribute-definitions \
4      AttributeName=customerId,AttributeType=S \
5      AttributeName=orderId,AttributeType=S \
6  --key-schema \
7      AttributeName=customerId,KeyType=HASH \
8      AttributeName=orderId,KeyType=RANGE \
9  --billing-mode PROVISIONED \
10  --provisioned-throughput ReadCapacityUnits=10,WriteCapacityUnits=5

1import { DynamoDBDocumentClient, GetCommand } from '@aws-sdk/lib-dynamodb';
2
3const result = await docClient.send(new GetCommand({
4  TableName: 'Orders',
5  Key: {
6    customerId: 'cust_A',
7    orderId: 'ORDER#2024-01-01T10:00:00',
8  },
9  ConsistentRead: true,  // strongly consistent — uses 1 RCU instead of 0.5
10}));
11
12console.log(result.Item);

1import { QueryCommand } from '@aws-sdk/lib-dynamodb';
2
3// Get all orders for cust_A in January 2024
4const result = await docClient.send(new QueryCommand({
5  TableName: 'Orders',
6  KeyConditionExpression: 'customerId = :cid AND orderId BETWEEN :start AND :end',
7  ExpressionAttributeValues: {
8    ':cid':   'cust_A',
9    ':start': 'ORDER#2024-01-01',
10    ':end':   'ORDER#2024-01-31T99:99:99',
11  },
12  ScanIndexForward: false,  // descending order (newest first)
13  Limit: 20,
14}));

1import { ScanCommand } from '@aws-sdk/lib-dynamodb';
2
3// Parallel scan — splits table into 4 segments for faster reads
4const segment = 0; // Run this concurrently with segments 1, 2, 3
5const result = await docClient.send(new ScanCommand({
6  TableName: 'Orders',
7  TotalSegments: 4,
8  Segment: segment,
9  FilterExpression: 'amount > :min',
10  ExpressionAttributeValues: { ':min': 100 },
11}));

1import { PutCommand, UpdateCommand, DeleteCommand } from '@aws-sdk/lib-dynamodb';
2
3// PutItem — creates or completely replaces an item
4await docClient.send(new PutCommand({
5  TableName: 'Orders',
6  Item: {
7    customerId: 'cust_A',
8    orderId: 'ORDER#2024-03-01T12:00:00',
9    amount: 59.99,
10    status: 'PENDING',
11  },
12  ConditionExpression: 'attribute_not_exists(customerId)',  // fail if already exists
13}));
14
15// UpdateItem — modify specific attributes without replacing the whole item
16await docClient.send(new UpdateCommand({
17  TableName: 'Orders',
18  Key: { customerId: 'cust_A', orderId: 'ORDER#2024-03-01T12:00:00' },
19  UpdateExpression: 'SET #s = :status, updatedAt = :ts ADD version :one',
20  ExpressionAttributeNames:  { '#s': 'status' },
21  ExpressionAttributeValues: {
22    ':status': 'SHIPPED',
23    ':ts':     new Date().toISOString(),
24    ':one':    1,
25  },
26  ConditionExpression: '#s = :pending',  // optimistic locking
27  ExpressionAttributeValues: {
28    ':status':  'SHIPPED',
29    ':ts':      new Date().toISOString(),
30    ':one':     1,
31    ':pending': 'PENDING',
32  },
33}));
34
35// DeleteItem — remove an item
36await docClient.send(new DeleteCommand({
37  TableName: 'Orders',
38  Key: { customerId: 'cust_A', orderId: 'ORDER#2024-03-01T12:00:00' },
39  ConditionExpression: 'attribute_exists(customerId)',
40}));

1aws dynamodb update-table --table-name Orders \
2  --attribute-definitions \
3      AttributeName=status,AttributeType=S \
4      AttributeName=createdAt,AttributeType=S \
5  --global-secondary-index-updates '[{
6    "Create": {
7      "IndexName": "status-createdAt-index",
8      "KeySchema": [
9        {"AttributeName":"status","KeyType":"HASH"},
10        {"AttributeName":"createdAt","KeyType":"RANGE"}
11      ],
12      "Projection": {"ProjectionType":"ALL"},
13      "ProvisionedThroughput": {"ReadCapacityUnits":5,"WriteCapacityUnits":5}
14    }
15  }]'

1import { TransactWriteCommand, TransactGetCommand } from '@aws-sdk/lib-dynamodb';
2
3// Transfer funds — debit one account, credit another atomically
4await docClient.send(new TransactWriteCommand({
5  TransactItems: [
6    {
7      Update: {
8        TableName: 'Accounts',
9        Key: { accountId: 'ACC-001' },
10        UpdateExpression: 'ADD balance :debit',
11        ConditionExpression: 'balance >= :amount',
12        ExpressionAttributeValues: { ':debit': -100, ':amount': 100 },
13      },
14    },
15    {
16      Update: {
17        TableName: 'Accounts',
18        Key: { accountId: 'ACC-002' },
19        UpdateExpression: 'ADD balance :credit',
20        ExpressionAttributeValues: { ':credit': 100 },
21      },
22    },
23    {
24      Put: {
25        TableName: 'Transactions',
26        Item: {
27          txId: 'TX-' + Date.now(),
28          from: 'ACC-001', to: 'ACC-002', amount: 100,
29          createdAt: new Date().toISOString(),
30        },
31        ConditionExpression: 'attribute_not_exists(txId)',  // idempotency check
32      },
33    },
34  ],
35}));

1aws dynamodb update-table --table-name Orders \
2  --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES

1import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
2import { DaxDocument } from 'amazon-dax-client';
3
4// Swap DynamoDB client for DAX client — all other code unchanged
5const daxClient = new DaxDocument({
6  endpoints: ['my-dax-cluster.abc123.dax-clusters.us-east-1.amazonaws.com:8111'],
7  region: 'us-east-1',
8});

1// Store a session that expires in 24 hours
2const expiresAt = Math.floor(Date.now() / 1000) + 86400; // Unix epoch seconds
3
4await docClient.send(new PutCommand({
5  TableName: 'Sessions',
6  Item: {
7    sessionId: 'sess_xyz',
8    userId: 'usr_01J8X',
9    data: { theme: 'dark' },
10    expiresAt,  // DynamoDB reads this attribute for TTL
11  },
12}));

1# Enable TTL on the "expiresAt" attribute
2aws dynamodb update-time-to-live \
3  --table-name Sessions \
4  --time-to-live-specification Enabled=true,AttributeName=expiresAt

1// ❌ HOT PARTITION: All writes to the same partition
2await docClient.send(new PutCommand({
3  TableName: 'Events',
4  Item: { pk: 'EVENT_LOG', sk: Date.now(), data: event },
5}));
6
7// ✅ SHARDED: Spread across 10 shards
8const SHARD_COUNT = 10;
9const shard = Math.floor(Math.random() * SHARD_COUNT);
10await docClient.send(new PutCommand({
11  TableName: 'Events',
12  Item: { pk: `EVENT_LOG#${shard}`, sk: Date.now(), data: event },
13}));
14
15// To read all shards, query each shard in parallel
16const queries = Array.from({ length: SHARD_COUNT }, (_, i) =>
17  docClient.send(new QueryCommand({
18    TableName: 'Events',
19    KeyConditionExpression: 'pk = :pk',
20    ExpressionAttributeValues: { ':pk': `EVENT_LOG#${i}` },
21  }))
22);
23const results = await Promise.all(queries);

1import { BatchGetCommand, BatchWriteCommand } from '@aws-sdk/lib-dynamodb';
2
3// BatchGetItem — up to 100 items across multiple tables
4const result = await docClient.send(new BatchGetCommand({
5  RequestItems: {
6    'Users':  { Keys: [{ userId: 'usr_01' }, { userId: 'usr_02' }] },
7    'Orders': { Keys: [{ customerId: 'cust_A', orderId: 'ORDER#001' }] },
8  },
9}));
10// result.UnprocessedKeys contains items that failed — retry with exponential backoff
11
12// BatchWriteItem — up to 25 put/delete operations across tables
13await docClient.send(new BatchWriteCommand({
14  RequestItems: {
15    'Orders': [
16      { PutRequest: { Item: { customerId: 'cust_A', orderId: 'ORDER#002', amount: 25 } } },
17      { DeleteRequest: { Key: { customerId: 'cust_A', orderId: 'ORDER#001' } } },
18    ],
19  },
20}));