One-to-many relationship patterns in DynamoDB - Step-by-Step Execution

Concept Flow - One-to-many relationship patterns

Start with Parent Item

↓

Store Parent with PK

↓

Add Child Items

↓

Child Items share Parent PK + unique SK

↓

Query by Parent PK

↓

Retrieve Parent + all Children

↓

Use results to show one-to-many

This flow shows how a parent item and multiple child items are stored and queried in DynamoDB using a shared partition key and unique sort keys to represent one-to-many relationships.

Execution Sample

DynamoDB

PK = 'USER#123'
SK = 'PROFILE'
// Parent item
PutItem(PK, SK, {name: 'Alice'})

// Child items
PutItem(PK, 'ORDER#1', {item: 'Book'})
PutItem(PK, 'ORDER#2', {item: 'Pen'})

// Query all for PK
Query(PK)

Stores a user as parent and their orders as children sharing the same PK but different SKs, then queries all items for that user.

Execution Table

Step	Action	PK	SK	Item Data	Result
1	Put parent item	USER#123	PROFILE	{name: 'Alice'}	Parent stored
2	Put child item 1	USER#123	ORDER#1	{item: 'Book'}	Child 1 stored
3	Put child item 2	USER#123	ORDER#2	{item: 'Pen'}	Child 2 stored
4	Query items by PK	USER#123	ALL	N/A	Returns parent + 2 children
5	Process results	N/A	N/A	N/A	One-to-many relationship shown
6	End	N/A	N/A	N/A	No more steps

💡 All items for PK 'USER#123' retrieved, showing one parent and multiple children

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
PK	undefined	USER#123	USER#123	USER#123	USER#123	USER#123
SK	undefined	PROFILE	ORDER#1	ORDER#2	ALL	ALL
Items Stored	0	1 (parent)	2 (parent + child1)	3 (parent + 2 children)	3 (queried)	3 (final)
Query Result	empty	empty	empty	empty	[parent, child1, child2]	[parent, child1, child2]

Key Moments - 3 Insights

Why do all child items share the same PK as the parent?

Because in DynamoDB one-to-many patterns, the PK groups related items together so querying by PK returns the parent and all its children (see execution_table step 4).

How do we distinguish between parent and child items if they share the same PK?

We use different SK values: the parent has a unique SK like 'PROFILE', children have SKs like 'ORDER#1', 'ORDER#2' (see execution_table steps 1-3).

What happens when we query by PK only?

We get all items with that PK, including the parent and all children, showing the one-to-many relationship (see execution_table step 4).

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the SK of the second child item stored?

A PROFILE

B ORDER#2

C ORDER#1

D USER#123

💡 Hint

Check the SK column in execution_table row for step 3

At which step does the query return all related items for the parent?

A Step 4

B Step 2

C Step 1

D Step 5

💡 Hint

Look at the Result column in execution_table for step 4

If the SK for child items were not unique, what would happen when querying by PK?

A Parent item would be missing

B All child items would still be returned correctly

C Only one child item would be returned

D Query would fail

💡 Hint

Refer to key_moments about SK uniqueness and execution_table steps 2-3

Concept Snapshot

One-to-many in DynamoDB:
- Use same PK for parent and children
- Use unique SKs to distinguish items
- Query by PK returns parent + all children
- SK pattern helps identify item type
- Efficient retrieval of related data

Full Transcript

This visual execution shows how to model one-to-many relationships in DynamoDB. We start by storing a parent item with a partition key (PK) and a sort key (SK). Then we add child items that share the same PK but have unique SKs. When we query by the PK, DynamoDB returns the parent and all child items together. This pattern groups related data and allows efficient retrieval. The SK helps us tell parent and children apart. The execution table traces each step: storing parent, storing children, querying, and processing results. The variable tracker shows how PK, SK, and stored items change over time. Key moments clarify why PK is shared and SK is unique. The quiz tests understanding of SK values, query results, and consequences of SK duplication.