Regex queries in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Find documents with names starting with 'A'

Given a collection users with documents containing a name field, which query returns all users whose names start with the letter 'A'?

MongoDB

db.users.find({ name: { $regex: '^A' } })

A db.users.find({ name: { $regex: '^A' } })

B db.users.find({ name: { $regex: 'A$' } })

C db.users.find({ name: { $regex: 'A' } })

D db.users.find({ name: { $regex: '^a' } })

💡 Hint

Use ^ to match the start of the string.

The caret ^ in regex means the start of the string. So ^A matches names starting with 'A'. Option A matches names ending with 'A'. Option A matches names containing 'A' anywhere. Option A matches names starting with lowercase 'a', which is case sensitive.

❓ query_result

intermediate

Find documents with emails ending in '.com'

Which MongoDB query finds all documents in contacts collection where the email field ends with '.com'?

MongoDB

db.contacts.find({ email: { $regex: '\.com$' } })

A db.contacts.find({ email: { $regex: '\.com' } })

B db.contacts.find({ email: { $regex: '^\.com' } })

C db.contacts.find({ email: { $regex: '.com' } })

D db.contacts.find({ email: { $regex: '\.com$' } })

💡 Hint

Use $ to match the end of the string and escape the dot.

The dollar sign $ matches the end of the string. The dot . is a special character in regex, so it must be escaped with a backslash \. to match a literal dot. Option D correctly matches emails ending with '.com'. Option D matches strings starting with '.com'. Option D matches any string containing 'com' with any character before it. Option D matches any string containing '.com' anywhere.

📝 Syntax

advanced

Identify the syntax error in regex query

Which of the following MongoDB queries has a syntax error and will fail to run?

A )} } '}4{d\}3{]Z-A[' :xeger$ { :edoc {(dnif.stcudorp.bd

B db.products.find({ code: { $regex: '[A-Z]{3}\d{4}' } })

C b.products.find({ code: { $regex: '[A-Z]{3}\d{4}' } })

D db.products.find({ code: { $regex: '[A-Z]{3}\d{4}' } }

💡 Hint

Check for missing brackets or braces.

Option B is missing the closing brace } for the find method call, causing a syntax error. The other options have correct syntax.

❓ optimization

advanced

Optimize regex query for case-insensitive search

You want to find all documents in employees where the department field contains the word 'sales' regardless of case. Which query is the most efficient and correct?

A db.employees.find({ department: { $regex: '(?i)sales' } })

B db.employees.find({ department: { $regex: '[Ss][Aa][Ll][Ee][Ss]' } })

C db.employees.find({ department: { $regex: 'sales', $options: 'i' } })

D db.employees.find({ department: { $regex: 'sales' } })

💡 Hint

Use regex options for case-insensitivity.

Option C uses the $options: 'i' flag to make the regex case-insensitive, which is efficient and clear. Option C tries to use inline case-insensitive flag which MongoDB does not support. Option C manually matches each letter case which is less efficient. Option C is case-sensitive and misses matches with different cases.

🧠 Conceptual

expert

Understanding regex anchoring in MongoDB queries

Consider the query db.logs.find({ message: { $regex: 'error' } }). Which statement best describes the behavior of this query?

A It matches documents where 'message' contains the substring 'error' anywhere.

B It matches documents where 'message' starts with 'error'.

C It matches documents where 'message' ends with 'error'.

D It matches documents where 'message' equals exactly 'error'.

💡 Hint

Think about what happens when no anchors are used in regex.

Without anchors like ^ or $, the regex matches the pattern anywhere in the string. So option A is correct. Options A and B require anchors. Option A requires exact match, which regex alone does not guarantee.

Practice

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

easy

A. It searches for documents where a field matches a text pattern.

B. It sorts documents in ascending order.

C. It updates documents with new values.

D. It deletes documents matching a condition.

Solution

1. Step 1: Understand the purpose of $regex

   The $regex operator is used to find text patterns inside string fields in MongoDB documents.

2. Step 2: Compare with other operations

   Sorting, updating, and deleting are different operations and do not use $regex.

3. Final Answer:

   It searches for documents where a field matches a text pattern. -> Option A

4. Quick Check:

   $regex = pattern search [OK]

Hint: Remember: $regex means 'match pattern' in text fields [OK]

Common Mistakes:

• Confusing $regex with sorting or updating operations
• Thinking $regex modifies data instead of searching
• Assuming $regex works on non-string fields

2. Which of the following is the correct syntax to find documents where the field name starts with 'A' using regex in MongoDB?

easy

A. {"name": {"$regex": "A$"}}

B. {"name": {"$regex": "A*"}}

C. {"name": {"$regex": "^A"}}

D. {"name": {"$regex": "[A]"}}

Solution

1. Step 1: Understand regex anchors

   The caret ^ means the start of the string, so ^A matches strings starting with 'A'.

2. Step 2: Check other options

   A$ matches strings ending with 'A', A* matches zero or more 'A's anywhere, and [A] matches any 'A' character anywhere.

3. Final Answer:

   {"name": {"$regex": "^A"}} -> Option C

4. Quick Check:

   Start with 'A' = ^A [OK]

Hint: Use ^ at start of pattern to match beginning of string [OK]

Common Mistakes:

• Using $ instead of ^ to match start
• Misunderstanding * as 'starts with'
• Using character class [] without anchors

3. Given the collection documents: [{"city": "London"}, {"city": "london"}, {"city": "Londonderry"}], what will the query {"city": {"$regex": "^London$", "$options": "i"}} return?

medium

A. []

B. [{"city": "London"}]

C. [{"city": "Londonderry"}]

D. [{"city": "London"}, {"city": "london"}]

Solution

1. Step 1: Analyze the regex pattern and options

   The pattern ^London$ matches exactly 'London' from start to end. The option i makes it case-insensitive.

2. Step 2: Check which documents match

   "London" matches exactly, "london" matches ignoring case, but "Londonderry" does not match because it has extra characters.

3. Final Answer:

   [{"city": "London"}, {"city": "london"}] -> Option D

4. Quick Check:

   Exact match ignoring case = [{"city": "London"}, {"city": "london"}] [OK]

Hint: Use ^ and $ for exact match; 'i' option ignores case [OK]

Common Mistakes:

• Ignoring case option and missing lowercase match
• Assuming partial matches without anchors
• Confusing $regex with substring search

4. Identify the error in this MongoDB query to find documents where title contains 'book' case-insensitive: {"title": {"$regex": "/book/i"}}

medium

A. The $regex operator cannot be used with strings.

B. The regex pattern should not be enclosed in slashes.

C. The $options field is missing.

D. The field name should be $pattern, not $regex.

Solution

1. Step 1: Understand MongoDB regex syntax

   In MongoDB, the regex pattern is a string without enclosing slashes. Options like 'i' go in a separate $options field.

2. Step 2: Identify the mistake in the query

   The pattern "/book/i" incorrectly includes slashes and option inside the string. It should be {"$regex": "book", "$options": "i"}.

3. Final Answer:

   The regex pattern should not be enclosed in slashes. -> Option B

4. Quick Check:

   MongoDB regex no slashes, use $options [OK]

Hint: Do not use /slashes/ in MongoDB regex patterns [OK]

Common Mistakes:

• Including slashes around regex pattern
• Putting options inside the pattern string
• Using wrong field names like $pattern

5. You want to find all documents where the description field contains either 'cat' or 'dog' (case-insensitive). Which MongoDB query correctly uses regex to achieve this?

hard

A. {"description": {"$regex": "cat|dog", "$options": "i"}}

B. {"description": {"$regex": "[cat|dog]", "$options": "i"}}

C. {"description": {"$regex": "(cat|dog)", "$options": "g"}}

D. {"description": {"$regex": "cat|dog"}}

Solution

1. Step 1: Understand regex alternation and options

   The pattern cat|dog matches either 'cat' or 'dog'. The i option makes it case-insensitive.

2. Step 2: Evaluate each option

   {"description": {"$regex": "cat|dog", "$options": "i"}} correctly uses the pattern and case-insensitive option. {"description": {"$regex": "[cat|dog]", "$options": "i"}} uses character class incorrectly, matching any single character 'c', 'a', 't', '|', 'd', 'o', or 'g'. {"description": {"$regex": "(cat|dog)", "$options": "g"}} uses g which is not a valid MongoDB regex option. {"description": {"$regex": "cat|dog"}} misses the case-insensitive option.

3. Final Answer:

   {"description": {"$regex": "cat|dog", "$options": "i"}} -> Option A

4. Quick Check:

   Use | for OR and 'i' for ignore case [OK]

Hint: Use | inside regex and $options: 'i' for case-insensitive [OK]

Common Mistakes:

• Using character classes [] instead of alternation |
• Using invalid regex options like 'g' in MongoDB
• Forgetting $options for case-insensitive search