Query depth and complexity in GraphQL - Step-by-Step Execution

Concept Flow - Query depth and complexity

Start Query

↓

Parse Query

↓

Calculate Depth

↓

Calculate Complexity

↓

Compare with Limits

↓

Execute

↓

Return Data

The query is parsed, its depth and complexity are calculated, then checked against limits to decide if it runs or is rejected.

Execution Sample

GraphQL

query {
  user {
    posts {
      comments {
        text
      }
    }
  }
}

This query fetches users, their posts, and comments text, showing nested depth and complexity.

Execution Table

Step	Action	Current Depth	Complexity Score	Decision
1	Start parsing query	0	0	Continue
2	Enter 'user' field	1	1	Continue
3	Enter 'posts' field inside 'user'	2	3	Continue
4	Enter 'comments' field inside 'posts'	3	6	Continue
5	Read 'text' field inside 'comments'	4	7	Continue
6	Calculate total depth = 4	4	7	Check limits
7	Calculate total complexity = 7	4	7	Check limits
8	Compare depth (4) with max allowed (5)	4	7	OK
9	Compare complexity (7) with max allowed (10)	4	7	OK
10	Execute query and return data	4	7	Done

💡 Query depth and complexity are within allowed limits, so query executes successfully.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
Current Depth	0	1	2	3	4	4
Complexity Score	0	1	3	6	7	7

Key Moments - 2 Insights

Why does the complexity score increase more than the depth at some steps?

Because complexity counts the number of fields and nested calls, not just depth. For example, at step 3, depth is 2 but complexity is 3 due to multiple fields inside.

What happens if the query depth exceeds the allowed maximum?

The query is rejected before execution to protect the server, as shown in the decision step after calculating depth (step 8).

Visual Quiz - 3 Questions

Look at the execution table, what is the complexity score after entering the 'comments' field (step 4)?

A 6

B 4

C 3

D 7

💡 Hint

Check the 'Complexity Score' column at step 4 in the execution table.

At which step does the query depth reach its maximum value?

A Step 6

B Step 3

C Step 5

D Step 9

💡 Hint

Look at the 'Current Depth' column and find the highest number.

If the max allowed complexity was 5 instead of 10, what would happen at step 9?

A Query would execute normally

B Query would be rejected due to high complexity

C Depth would be recalculated

D Complexity would decrease

💡 Hint

Compare the complexity score at step 9 with the new max allowed complexity.

Concept Snapshot

Query depth and complexity measure how nested and costly a GraphQL query is.
Depth counts nested levels; complexity counts fields and nested calls.
Servers set max limits to avoid slow or harmful queries.
Queries exceeding limits are rejected before running.
Calculations happen after parsing, before execution.

Full Transcript

This visual trace shows how a GraphQL query is processed to check its depth and complexity. The query is parsed, then each nested field increases depth and complexity scores. The depth is the number of nested levels, while complexity counts the total fields and nested calls. After calculating these, the server compares them to allowed maximums. If the query is within limits, it runs and returns data. If not, it is rejected to protect server performance. This helps keep queries efficient and safe.