Regex queries in MongoDB - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to find documents where the 'name' field starts with 'A'.

MongoDB

db.collection.find({ name: { $regex: /^[1]/ } })

Drag options to blanks, or click blank then click option'

AA

Ba

C^A

D.*A

Attempts:

3 left

💡 Hint

Common Mistakes

Including the caret (^) inside the blank causes a syntax error.

Using lowercase 'a' will not match uppercase 'A'.

The regex /^A/ matches strings starting with 'A'. Here, the caret (^) is outside the blank, so only 'A' is needed.

2fill in blank

medium

Complete the code to find documents where the 'email' field contains 'gmail'.

MongoDB

db.collection.find({ email: { $regex: /[1]/ } })

Drag options to blanks, or click blank then click option'

Agmail

Bgmail$

C^gmail

D^gmail$

Attempts:

3 left

💡 Hint

Common Mistakes

Using '^gmail' matches only strings starting with 'gmail'.

Using 'gmail$' matches only strings ending with 'gmail'.

The regex /gmail/ matches any string containing 'gmail' anywhere.

3fill in blank

hard

Fix the error in the code to find documents where 'username' ends with '123'.

MongoDB

db.collection.find({ username: { $regex: /[1]$/ } })

Drag options to blanks, or click blank then click option'

A.*123

B^123

C123$

D123

Attempts:

3 left

💡 Hint

Common Mistakes

Including '$' inside the blank causes a syntax error.

Using '^123' matches start of string, not end.

The dollar sign ($) is already outside the blank, so inside the blank we only put '123'.

4fill in blank

hard

Fill both blanks to find documents where 'title' contains 'data' ignoring case.

MongoDB

db.collection.find({ title: { $regex: /[1]/, $options: '[2]' } })

Drag options to blanks, or click blank then click option'

Adata

Bi

Cg

D^data

Attempts:

3 left

💡 Hint

Common Mistakes

Using '^data' matches only start of string.

Using 'g' option is for global search, not needed here.

The regex /data/ matches 'data' anywhere. The option 'i' makes the search case-insensitive.

5fill in blank

hard

Fill all three blanks to find documents where 'description' starts with 'Error' and ends with a digit.

MongoDB

db.collection.find({ description: { $regex: /^[1].*[2]$/, $options: '[3]' } })

Drag options to blanks, or click blank then click option'

AError

B\d

Ci

Dg

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to escape the backslash in '\d'.

Using 'g' option which is not needed for find queries.

The regex /^Error.*\d$/ matches strings starting with 'Error' and ending with a digit. The 'i' option ignores case.

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