MongoDB CRUD Interview Questions

updateOne changes the first matching document and updateMany every match; both take update operators such as $set, so fields you do not name stay. replaceOne swaps the whole document for a new one, keeping only _id: fields you leave out are gone. The driver refuses an update document without operators, which stops you from replacing a document by accident.

$set and $unset (add, change or remove a field), $inc and $mul (arithmetic), $min and $max (keep the smaller or larger value), $rename, $currentDate, and for arrays $push, $addToSet, $pull and $pop. One update can use several operators, and the whole update of one document is atomic. $inc on a missing field creates it.

const { MongoClient } = require('mongodb');
const client = new MongoClient('mongodb://localhost:27017');

async function main() {
  const items = client.db('shop').collection('items');
  await items.insertOne({ sku: 'pen', stock: 10, price: 20, promo: true });
  await items.updateOne(
    { sku: 'pen' },
    { $inc: { stock: -3, sold: 3 }, $min: { price: 15 }, $unset: { promo: '' } }
  );
  const pen = await items.findOne({ sku: 'pen' });
  console.log(pen.stock, pen.sold, pen.price, pen.promo);
}
main().finally(() => client.close());

It prints db,db,node | db,node. $push always appends, so pushed gets a second db. $addToSet appends only values not already in the array, so added skips db and gains node. $addToSet does not remove duplicates that are already there. Both take $each to add several values, and $pull removes every element equal to a value.

It prints 0 1 1 1 and 4 web. With upsert: true, no match means insert: MongoDB builds the document from the filter's equality fields (user: 'asha'), then applies the update, so items starts at 2. $setOnInsert fields are written only on that insert. The second call matches and modifies. Two concurrent upserts can both insert unless a unique index covers the filter field.

It prints 3 1. matchedCount counts the documents the filter selected; modifiedCount counts the ones that actually changed. Two users already had active: true, and MongoDB does not rewrite a document when the update would leave it the same. Check matchedCount to know a record exists, modifiedCount to know something changed.

It prints 41 43. findOneAndUpdate finds, updates and returns one document atomically, and by default it returns the document as it was before the update; returnDocument: 'after' returns the new version. That atomicity is why it is the standard way to hand out sequence numbers: two callers never get the same value. Driver 6 returns the document itself; older drivers wrapped it in { value }.

With the positional operators. $ updates the first element the query matched (the array field must be in the filter), $[] updates every element, and $[name] with arrayFilters updates the elements that match a condition.

// add 1 to the qty of the item with sku 'b'
db.orders.updateOne({ _id: 1, 'items.sku': 'b' }, { $inc: { 'items.$.qty': 1 } })

// mark every item as shipped
db.orders.updateOne({ _id: 1 }, { $set: { 'items.$[].shipped': true } })

// set qty to 0 for items cheaper than 5
db.orders.updateOne(
  { _id: 1 },
  { $set: { 'items.$[cheap].qty': 0 } },
  { arrayFilters: [{ 'cheap.price': { $lt: 5 } }] }
)

deleteOne(filter) removes the first match and deleteMany(filter) every match; both return deletedCount. deleteMany({}) empties a collection but keeps its indexes and options, while drop() removes the collection with its indexes and is much faster for clearing everything. Many apps soft delete instead (a deletedAt field), so records can be restored and audited.

const { MongoClient } = require('mongodb');
const client = new MongoClient('mongodb://localhost:27017');

async function main() {
  const logs = client.db('app').collection('logs');
  await logs.insertMany([{ level: 'info' }, { level: 'error' }, { level: 'info' }]);
  const one = await logs.deleteOne({ level: 'info' });
  const many = await logs.deleteMany({ level: 'info' });
  console.log(one.deletedCount, many.deletedCount, await logs.countDocuments());
}
main().finally(() => client.close());

insertMany is ordered by default: it inserts in sequence and stops at the first error, so the documents before it stay inserted and the rest are skipped. With { ordered: false } the server tries every document and reports all failures together, which is also faster for bulk loads. Either way there is no rollback; use a transaction if the batch must be all or nothing.

try {
  await users.insertMany(docs, { ordered: false });
} catch (err) {
  // MongoBulkWriteError
  console.log(err.insertedCount, err.writeErrors.length);
}

countDocuments(filter) counts matching documents by running a query: exact, can use an index, but costs a scan. estimatedDocumentCount() takes no filter and reads the total from collection metadata: instant, but it can be off after an unclean shutdown, and on a sharded cluster it can include orphaned documents. The old count() is deprecated in the drivers.

const { MongoClient } = require('mongodb');
const client = new MongoClient('mongodb://localhost:27017');

async function main() {
  const orders = client.db('shop').collection('orders');
  await orders.insertMany([{ status: 'paid' }, { status: 'new' }, { status: 'paid' }]);
  console.log(await orders.countDocuments({ status: 'paid' }));
  console.log(await orders.estimatedDocumentCount());
}
main().finally(() => client.close());