Insert with arrays in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What documents are inserted with this array insert?

Given the following MongoDB insert command, what documents will be stored in the collection?

MongoDB

db.students.insertMany([
  { name: "Alice", scores: [85, 90, 88] },
  { name: "Bob", scores: [78, 82, 80] }
])

A [{ name: "Alice", scores: [85, 90, 88] }, { name: "Bob", scores: [78, 82, 80] }]

B [{ name: "Alice" }, { name: "Bob" }, { scores: [85, 90, 88] }, { scores: [78, 82, 80] }]

C [{ name: "Alice", scores: 85 }, { name: "Bob", scores: 78 }]

D [{ name: "Alice", scores: [85] }, { name: "Bob", scores: [78] }]

💡 Hint

Remember that insertMany inserts each object in the array as a separate document.

The insertMany method inserts each object in the array as a separate document, preserving the array field 'scores' as is.

🧠 Conceptual

intermediate

How does MongoDB handle arrays in inserted documents?

When inserting a document with an array field in MongoDB, how is the array stored?

A MongoDB does not support arrays in documents.

B Each element of the array is stored as a separate document.

C The array elements are flattened into separate fields with numeric keys.

D The array is stored as a single field containing all elements in order.

💡 Hint

Think about how JSON arrays are represented in MongoDB documents.

MongoDB stores arrays as a single field containing an ordered list of elements, preserving the array structure.

📝 Syntax

advanced

Which insert command correctly inserts multiple documents with array fields?

Choose the correct MongoDB command to insert two documents, each having a 'tags' array field.

A db.collection.insert([{ name: "Item1", tags: "red", "large" }, { name: "Item2", tags: "blue", "small" }])

B db.collection.insertMany({ name: "Item1", tags: ["red", "large"] }, { name: "Item2", tags: ["blue", "small"] })

C db.collection.insertMany([{ name: "Item1", tags: ["red", "large"] }, { name: "Item2", tags: ["blue", "small"] }])

D db.collection.insertMany([{ name: "Item1", tags: "red", "large" }, { name: "Item2", tags: "blue", "small" }])

💡 Hint

Check the syntax for insertMany and how arrays are represented.

Option C correctly uses insertMany with an array of documents, each having a 'tags' array field. Other options have syntax errors or wrong array usage.

❓ optimization

advanced

Best practice for inserting many documents with large arrays?

You need to insert 10,000 documents, each with a large array field. What is the best approach to optimize insertion speed in MongoDB?

A Use insertMany with batches of documents, each batch containing multiple documents with arrays.

B Insert each document one by one using insertOne to avoid memory issues.

C Convert arrays to strings before inserting to reduce size.

D Insert all 10,000 documents in a single insertMany call without batching.

💡 Hint

Think about balancing batch size and memory usage.

Batching inserts with insertMany improves performance and avoids memory overload compared to single inserts or one huge batch.

🔧 Debug

expert

Why does this insertMany command fail?

Consider this command: db.products.insertMany([ { name: "Pen", colors: "blue", "red" }, { name: "Pencil", colors: ["yellow", "black"] } ]) Why does it fail?

A MongoDB does not allow arrays in documents.

B The first document's 'colors' field is incorrectly formatted; array elements must be inside square brackets.

C insertMany requires documents to have the same fields.

D The second document's array syntax is invalid.

💡 Hint

Look carefully at how the 'colors' field is written in the first document.

The first document tries to assign multiple values to 'colors' without using an array (square brackets), causing a syntax error.

Practice

1. What does the insertMany() method do in MongoDB?

easy

A. Inserts multiple documents into a collection at once

B. Deletes multiple documents from a collection

C. Updates multiple documents in a collection

D. Finds multiple documents in a collection

Solution

1. Step 1: Understand the purpose of insertMany()

   The insertMany() method is used to add several documents to a MongoDB collection in one operation.

2. Step 2: Compare with other operations

   Deleting, updating, or finding documents are done by other methods like deleteMany(), updateMany(), and find().

3. Final Answer:

   Inserts multiple documents into a collection at once -> Option A

4. Quick Check:

   insertMany() = Inserts multiple documents [OK]

Hint: insertMany() adds many documents in one call [OK]

Common Mistakes:

• Confusing insertMany() with update or delete methods
• Thinking insertMany() inserts only one document
• Assuming insertMany() returns documents instead of inserting

2. Which of the following is the correct syntax to insert multiple documents using insertMany()?

easy

A. db.collection.insertMany('name: Alice', 'name: Bob')

B. db.collection.insertMany({name: 'Alice'}, {name: 'Bob'})

C. db.collection.insertMany([{name: 'Alice'}, {name: 'Bob'}])

D. db.collection.insertMany(name: 'Alice', name: 'Bob')

Solution

1. Step 1: Check the parameter type for insertMany()

   The method requires an array of documents, so the argument must be inside square brackets [].

2. Step 2: Validate the options

   Only db.collection.insertMany([{name: 'Alice'}, {name: 'Bob'}]) correctly passes an array of objects. The other options pass multiple arguments or wrong types, causing syntax errors.

3. Final Answer:

   db.collection.insertMany([{name: 'Alice'}, {name: 'Bob'}]) -> Option C

4. Quick Check:

   insertMany() needs an array of documents [OK]

Hint: Use square brackets [] to pass multiple documents [OK]

Common Mistakes:

• Passing documents without array brackets
• Using multiple arguments instead of one array
• Using strings instead of objects for documents

3. What will be the result of this code?

db.users.insertMany([
  {name: 'John', age: 25},
  {name: 'Jane', age: 30}
])
const count = db.users.countDocuments()

medium

A. Syntax error occurs

B. count will be 1

C. count will be 0

D. count will be 2

Solution

1. Step 1: Understand insertMany() effect

   The insertMany() call inserts two documents into the users collection.

2. Step 2: Count documents after insertion

   The countDocuments() method returns the total number of documents in the collection, which is 2 after insertion.

3. Final Answer:

   count will be 2 -> Option D

4. Quick Check:

   2 documents inserted, countDocuments() = 2 [OK]

Hint: insertMany() adds all docs; countDocuments() counts them [OK]

Common Mistakes:

• Assuming countDocuments() runs before insertMany() completes
• Thinking insertMany() inserts only one document
• Confusing countDocuments() with count() method

4. Identify the error in this MongoDB insertMany() usage:

db.products.insertMany(
  {name: 'Pen', price: 1.5},
  {name: 'Pencil', price: 0.5}
)

medium

A. insertMany() cannot insert more than one document

B. Missing array brackets around documents

C. Documents have invalid field names

D. Using insertOne() instead of insertMany()

Solution

1. Step 1: Check the argument format for insertMany()

   The method requires a single array containing all documents, but here documents are passed as separate arguments.

2. Step 2: Identify the fix

   Wrapping the documents inside square brackets [] fixes the syntax: insertMany([{...}, {...}]).

3. Final Answer:

   Missing array brackets around documents -> Option B

4. Quick Check:

   insertMany() needs an array of documents [OK]

Hint: Always wrap multiple docs in [] for insertMany() [OK]

Common Mistakes:

• Passing multiple documents as separate arguments
• Confusing insertMany() with insertOne()
• Assuming insertMany() accepts objects directly without array

5. You want to insert a list of users but only those with an age above 18. Which MongoDB operation correctly inserts only the valid users?

const users = [
  {name: 'Anna', age: 17},
  {name: 'Ben', age: 20},
  {name: 'Cara', age: 22}
];
// Which code inserts only users older than 18?

hard

A. db.users.insertMany(users.filter(u => u.age > 18))

B. db.users.insertMany(users)

C. db.users.insertMany(users.map(u => u.age > 18))

D. db.users.insertMany(users.filter(u => u.age < 18))

Solution

1. Step 1: Filter users by age before insertion

   Use JavaScript's filter() to keep only users with age greater than 18.

2. Step 2: Pass filtered array to insertMany()

   Passing the filtered array inserts only valid users. Inserting all users includes invalid ones, mapping to booleans creates invalid documents, and filtering under 18 selects the wrong users.

3. Final Answer:

   db.users.insertMany(users.filter(u => u.age > 18)) -> Option A

4. Quick Check:

   Filter first, then insertMany() [OK]

Hint: Filter array before insertMany() to insert selected docs [OK]

Common Mistakes:

• Inserting all users without filtering
• Using map instead of filter, causing wrong data
• Filtering with wrong condition (age < 18)