Sorting arguments in GraphQL - Time & Space Complexity

Time Complexity: Sorting arguments

O(n log n)

Understanding Time Complexity

When we use sorting arguments in GraphQL queries, the system arranges data in a certain order before giving results.

We want to know how the time to get sorted results grows as the data size grows.

Scenario Under Consideration

Analyze the time complexity of the following GraphQL query with sorting.

query GetUsersSorted {
  users(orderBy: {field: "name", direction: ASC}) {
    id
    name
    email
  }
}
    

This query fetches a list of users sorted by their name in ascending order.

Identify Repeating Operations

Look for repeated steps that take time as data grows.

• Primary operation: Sorting the list of users by their name.
• How many times: The sorting process compares and arranges all user entries once per query.

How Execution Grows With Input

Sorting takes more time as the number of users increases.

Input Size (n)	Approx. Operations
10	About 30 comparisons
100	About 700 comparisons
1000	About 10,000 comparisons

Pattern observation: The number of operations grows faster than the number of users, roughly multiplying by a bit more than n each time.

Final Time Complexity

Time Complexity: O(n log n)

This means sorting takes a bit more than linear time, growing faster as the list gets bigger but still efficient for many users.

Common Mistake

[X] Wrong: "Sorting takes the same time no matter how many users there are."

[OK] Correct: Sorting compares many pairs of items, so more users mean more comparisons and longer time.

Interview Connect

Understanding how sorting affects query time helps you explain data fetching performance clearly and confidently.

Self-Check

"What if we added a filter to reduce the number of users before sorting? How would the time complexity change?"

Practice

1. What does the orderBy argument do in a GraphQL query?

easy

A. It sorts the returned data by a specified field and direction.

B. It filters the data to only include certain fields.

C. It limits the number of results returned.

D. It groups the data by a specific field.

Solution

1. Step 1: Understand the purpose of orderBy

   The orderBy argument is used to arrange data in a specific order based on a field.

2. Step 2: Identify sorting behavior

   It sorts data either ascending (ASC) or descending (DESC) by the chosen field.

3. Final Answer:

   It sorts the returned data by a specified field and direction. -> Option A

4. Quick Check:

   Sorting = orderBy usage [OK]

Hint: Remember: orderBy controls sorting order in queries [OK]

Common Mistakes:

• Confusing orderBy with filtering or limiting results
• Thinking orderBy groups data instead of sorting
• Assuming orderBy changes the data fields returned

2. Which of the following is the correct syntax to sort users by their name in ascending order using orderBy?

easy

A. { users(orderBy: [name, ASC]) { id name } }

B. { users(orderBy: name ASC) { id name } }

C. { users(orderBy: { name: ASC }) { id name } }

D. { users(orderBy: { ASC: name }) { id name } }

Solution

1. Step 1: Review GraphQL orderBy syntax

   The correct syntax uses an object with the field as key and direction as value inside curly braces.

2. Step 2: Match syntax to options

   { users(orderBy: { name: ASC }) { id name } } matches this pattern: { name: ASC }. Others use incorrect formats.

3. Final Answer:

   { users(orderBy: { name: ASC }) { id name } } -> Option C

4. Quick Check:

   Correct orderBy syntax = { users(orderBy: { name: ASC }) { id name } } [OK]

Hint: Use curly braces with field: direction inside orderBy [OK]

Common Mistakes:

• Using parentheses or brackets incorrectly in orderBy
• Placing direction before field name
• Omitting curly braces around orderBy argument

3. Given this GraphQL query:

{ products(orderBy: { price: DESC }) { id name price } }

What will be the order of products in the result?

medium

A. Products sorted by price from highest to lowest.

B. Products sorted by price from lowest to highest.

C. Products sorted alphabetically by name.

D. Products returned in random order.

Solution

1. Step 1: Identify sorting field and direction

   The query uses orderBy: { price: DESC }, meaning sort by price descending.

2. Step 2: Understand descending order

   Descending order means highest values come first, then lower values.

3. Final Answer:

   Products sorted by price from highest to lowest. -> Option A

4. Quick Check:

   DESC means highest to lowest [OK]

Hint: DESC means descending (high to low), ASC means ascending (low to high) [OK]

Common Mistakes:

• Confusing DESC with ascending order
• Assuming sorting is by name instead of price
• Thinking orderBy does not affect order

4. You wrote this query to sort posts by date ascending:

{ posts(orderBy: { date: ASC }) { id title date } }

But you get an error. What is the likely mistake?

medium

A. You must use sortBy instead of orderBy.

B. The orderBy argument should be a list, not an object.

C. The direction ASC is not valid in GraphQL.

D. The date field is missing from the schema.

Solution

1. Step 1: Check schema fields

   If date is not defined in the posts schema, sorting by it causes an error.

2. Step 2: Validate other options

   orderBy accepts an object, ASC is valid, and sortBy is not standard GraphQL.

3. Final Answer:

   The date field is missing from the schema. -> Option D

4. Quick Check:

   Sorting field must exist in schema [OK]

Hint: Ensure sorting field exists in schema before using orderBy [OK]

Common Mistakes:

• Using invalid direction keywords
• Confusing orderBy with other arguments
• Assuming orderBy requires a list always

5. You want to fetch a list of employees sorted first by department ascending, then by salary descending. Which orderBy argument correctly achieves this?

hard

A. { employees(orderBy: { department: ASC, salary: DESC }) { id name department salary } }

B. { employees(orderBy: [{ department: ASC }, { salary: DESC }]) { id name department salary } }

C. { employees(orderBy: [department: ASC, salary: DESC]) { id name department salary } }

D. { employees(orderBy: { salary: DESC, department: ASC }) { id name department salary } }

Solution

1. Step 1: Understand multi-level sorting syntax

   To sort by multiple fields, orderBy usually takes a list of objects, each specifying a field and direction.

2. Step 2: Match correct syntax

   { employees(orderBy: [{ department: ASC }, { salary: DESC }]) { id name department salary } } uses a list with two objects: first { department: ASC }, then { salary: DESC }, which is correct.

3. Step 3: Check other options

   { employees(orderBy: { department: ASC, salary: DESC }) { id name department salary } } uses a single object with two keys, which may not guarantee order. { employees(orderBy: [department: ASC, salary: DESC]) { id name department salary } } has invalid syntax. { employees(orderBy: { salary: DESC, department: ASC }) { id name department salary } } reverses sorting priority.

4. Final Answer:

   { employees(orderBy: [{ department: ASC }, { salary: DESC }]) { id name department salary } } -> Option B

5. Quick Check:

   Multi-field orderBy = list of objects [OK]

Hint: Use a list of objects for multi-level sorting in orderBy [OK]

Common Mistakes:

• Using a single object for multiple sort fields
• Reversing the order of sorting priorities
• Incorrect syntax for list of sorting fields