Adjacency list pattern in DynamoDB - Step-by-Step Execution

Concept Flow - Adjacency list pattern

Start with a node

↓

Store node with unique ID

↓

Store references (IDs) of connected nodes

↓

To find neighbors, query by stored references

↓

Repeat for each node

↓

Traverse graph by following references

Each node stores IDs of its connected nodes. To find neighbors, we look up these IDs. This builds a graph using references.

Execution Sample

DynamoDB

Node1 = {"id": "1", "name": "A", "neighbors": ["2", "3"]}
Node2 = {"id": "2", "name": "B", "neighbors": ["1"]}
Node3 = {"id": "3", "name": "C", "neighbors": ["1"]}

Three nodes with IDs and neighbor lists showing connections.

Execution Table

Step	Action	Node ID	Neighbors Stored	Query Result	Notes
1	Create node	1	["2", "3"]	None	Node A created with neighbors 2 and 3
2	Create node	2	["1"]	None	Node B created with neighbor 1
3	Create node	3	["1"]	None	Node C created with neighbor 1
4	Query neighbors of node 1	1	["2", "3"]	[Node 2, Node 3]	Lookup neighbors by IDs
5	Query neighbors of node 2	2	["1"]	[Node 1]	Lookup neighbor by ID
6	Query neighbors of node 3	3	["1"]	[Node 1]	Lookup neighbor by ID
7	Traversal example	1	["2", "3"]	[Node 2, Node 3]	Traverse from node 1 to neighbors
8	Traversal example	2	["1"]	[Node 1]	Traverse from node 2 back to node 1
9	Traversal example	3	["1"]	[Node 1]	Traverse from node 3 back to node 1
10	End				All nodes created and neighbors queried

💡 All nodes created and neighbor queries completed, traversal demonstrated

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
Node1	None	{"id": "1", "name": "A", "neighbors": ["2", "3"]}	{"id": "1", "name": "A", "neighbors": ["2", "3"]}	{"id": "1", "name": "A", "neighbors": ["2", "3"]}	{"id": "1", "name": "A", "neighbors": ["2", "3"]}
Node2	None	None	{"id": "2", "name": "B", "neighbors": ["1"]}	{"id": "2", "name": "B", "neighbors": ["1"]}	{"id": "2", "name": "B", "neighbors": ["1"]}
Node3	None	None	None	{"id": "3", "name": "C", "neighbors": ["1"]}	{"id": "3", "name": "C", "neighbors": ["1"]}
QueryResult	None	None	None	None	[Node 2, Node 3] after querying neighbors of Node 1

Key Moments - 3 Insights

Why do we store neighbor IDs instead of full neighbor data inside each node?

Storing only neighbor IDs avoids data duplication and keeps nodes small. We fetch full neighbor data by querying these IDs as shown in execution_table rows 4-6.

How do we find neighbors of a node?

We look at the 'neighbors' list of IDs in the node, then query the database for those IDs. This is shown in execution_table rows 4-6.

What happens if a node has no neighbors?

Its 'neighbors' list is empty. Querying neighbors returns an empty list, meaning no connected nodes.

Visual Quiz - 3 Questions

Look at the execution_table at step 4. What nodes are neighbors of node 1?

A Nodes 2 and 3

B Node 1 only

C No neighbors

D Nodes 1, 2, and 3

💡 Hint

Check the 'Query Result' column at step 4 in execution_table

At which step do we create node 3 with its neighbors?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Node ID' columns in execution_table

If node 2 had no neighbors, how would the 'Neighbors Stored' column change at step 2?

A ["1"]

B []

C ["2"]

D null

💡 Hint

Neighbors list is empty if no neighbors, see variable_tracker for neighbors format

Concept Snapshot

Adjacency list pattern stores each node with a unique ID and a list of neighbor IDs.
To find neighbors, query nodes by these IDs.
This avoids data duplication and models graph connections clearly.
Common in DynamoDB for graph-like data.
Traversal follows neighbor references step-by-step.

Full Transcript

The adjacency list pattern stores graph nodes with unique IDs and lists of neighbor IDs. Each node references connected nodes by their IDs, not by embedding full data. This keeps data small and avoids duplication. To find neighbors, we query the database for nodes matching the stored neighbor IDs. The execution table shows creating three nodes and querying their neighbors. Traversal follows these references to move through the graph. Key moments clarify why IDs are stored, how neighbors are found, and what happens if no neighbors exist. The visual quiz tests understanding of neighbor queries and node creation steps. This pattern is common in DynamoDB for representing graphs efficiently.