$eq for equality in MongoDB - Time & Space Complexity

Time Complexity: $eq for equality

O(n)

Understanding Time Complexity

When we use $eq in MongoDB, we want to find documents where a field matches a specific value.

We ask: How does the time to find these documents grow as the collection gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

db.collection.find({ age: { $eq: 25 } })

This query finds all documents where the age field equals 25.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Checking each document's age field to see if it equals 25.
• How many times: Once for each document in the collection if no index is used.

How Execution Grows With Input

As the collection grows, the number of documents to check grows too.

Input Size (n)	Approx. Operations
10	10 checks
100	100 checks
1000	1000 checks

Pattern observation: The work grows directly with the number of documents.

Final Time Complexity

Time Complexity: O(n)

This means the time to find matching documents grows in a straight line with the collection size.

Common Mistake

[X] Wrong: "Using $eq always finds results instantly no matter the collection size."

[OK] Correct: Without an index, MongoDB must check each document one by one, so bigger collections take more time.

Interview Connect

Understanding how simple equality checks scale helps you explain database query performance clearly and confidently.

Self-Check

"What if we added an index on the age field? How would the time complexity change?"

Practice

1. What does the $eq operator do in a MongoDB query?

easy

A. It sorts documents in ascending order.

B. It deletes documents from the collection.

C. It updates documents with new values.

D. It matches documents where a field is equal to a specified value.

Solution

1. Step 1: Understand the purpose of $eq

   The $eq operator is used to filter documents where a field exactly matches a given value.

2. Step 2: Compare with other options

   Sorting, updating, and deleting are different operations and not related to $eq.

3. Final Answer:

   It matches documents where a field is equal to a specified value. -> Option D

4. Quick Check:

   $eq means equality match [OK]

Hint: Remember: $eq means 'equals' in queries [OK]

Common Mistakes:

• Confusing $eq with sorting or updating operators
• Thinking $eq modifies data instead of filtering
• Assuming $eq works for inequality

2. Which of the following is the correct syntax to find documents where the field age equals 30 using $eq?

easy

A. { age: { $eq: 30 } }

B. { $eq: { age: 30 } }

C. { age: $eq: 30 }

D. { age == 30 }

Solution

1. Step 1: Recall MongoDB query syntax for $eq

   The correct syntax uses the field name as key and an object with $eq as key and the value to match as value: { age: { $eq: 30 } }.

2. Step 2: Identify incorrect syntax

   Options B, C, and D do not follow MongoDB query syntax rules and will cause errors.

3. Final Answer:

   { age: { $eq: 30 } } -> Option A

4. Quick Check:

   Field: { $eq: value } format [OK]

Hint: Use { field: { $eq: value } } for equality [OK]

Common Mistakes:

• Placing $eq outside the field key
• Using double colons or wrong operators
• Using JavaScript equality syntax instead of MongoDB

3. Given the collection users with documents:

{ "name": "Alice", "age": 25 }, { "name": "Bob", "age": 30 }, { "name": "Carol", "age": 30 }

What will the query db.users.find({ age: { $eq: 30 } }) return?

medium

A. [{ "name": "Bob", "age": 30 }, { "name": "Carol", "age": 30 }]

B. [] (empty array)

C. [{ "name": "Alice", "age": 25 }]

D. Syntax error

Solution

1. Step 1: Understand the query condition

   The query looks for documents where age equals 30.

2. Step 2: Check documents matching the condition

   Bob and Carol have age 30, so both documents match and will be returned.

3. Final Answer:

   [{ "name": "Bob", "age": 30 }, { "name": "Carol", "age": 30 }] -> Option A

4. Quick Check:

   age == 30 returns Bob and Carol [OK]

Hint: Look for documents where field equals value [OK]

Common Mistakes:

• Returning documents with age not equal to 30
• Expecting only one document instead of all matches
• Thinking $eq causes syntax error

4. You wrote the query db.products.find({ price: $eq: 100 }) but it gives an error. What is wrong?

medium

A. Field name price is invalid

B. Missing curly braces around $eq: 100 value

C. You cannot use $eq with numbers

D. The collection name products is incorrect

Solution

1. Step 1: Check the query syntax

   The $eq operator must be inside an object as the value for the field key, like { price: { $eq: 100 } }.

2. Step 2: Identify the missing braces

   The query is missing curly braces around $eq: 100, causing a syntax error.

3. Final Answer:

   Missing curly braces around $eq: 100 value -> Option B

4. Quick Check:

   Use { field: { $eq: value } } syntax [OK]

Hint: Always wrap $eq and value in braces { } [OK]

Common Mistakes:

• Omitting braces around $eq operator
• Assuming $eq works without object syntax
• Blaming collection or field name incorrectly

5. You want to find documents in orders where the status is exactly "shipped" and the quantity is 10. Which query correctly uses $eq for both conditions?

hard

A. db.orders.find({ status: "shipped", quantity: 10 })

B. db.orders.find({ $eq: { status: "shipped", quantity: 10 } })

C. db.orders.find({ status: { $eq: "shipped" }, quantity: { $eq: 10 } })

D. db.orders.find({ status == "shipped", quantity == 10 })

Solution

1. Step 1: Use $eq for each field separately

   Each field must have its own $eq operator inside an object: { status: { $eq: "shipped" } } and { quantity: { $eq: 10 } }.

2. Step 2: Combine conditions in one query object

   Put both conditions inside the find query object to filter documents matching both.

3. Final Answer:

   db.orders.find({ status: { $eq: "shipped" }, quantity: { $eq: 10 } }) -> Option C

4. Quick Check:

   Use separate $eq for each field [OK]

Hint: Use separate $eq for each field in the query [OK]

Common Mistakes:

• Trying to use one $eq for multiple fields
• Using JavaScript equality operators in query
• Omitting $eq and relying on implicit equality