What is the difference between a query operator and an update operator?

Query operators like $gt and $in appear in the filter document and decide which documents match. Update operators like $set and $inc appear in the update document and decide how matched documents are modified.

When do I need $expr?

Use $expr when a query must compare two fields of the same document, for example matching documents where spent is greater than budget. It lets you use aggregation expressions inside an ordinary find() filter.

What does $lookup do?

$lookup performs a left outer join from the current collection to another collection within an aggregation pipeline, adding an array field of matching documents. It is MongoDB's equivalent of a SQL JOIN.

Why does $min appear in two categories?

The same $ name can mean different things by context. $min as an update operator only writes the new value if it is lower than the current one, while $min as an aggregation accumulator returns the smallest value in a group.

What is the difference between $push and $addToSet?

$push always appends a value to an array, allowing duplicates. $addToSet appends only if the value is not already present, keeping the array a set of unique values.

MongoDB Operators Reference

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

Find the right MongoDB operator fast

MongoDB operators span several worlds: query operators that filter documents, update modifiers that change them, aggregation pipeline stages that transform a stream of documents, aggregation expressions that compute values, and projection operators that shape the output. This reference lets you search all of them by name or description and filter by category. It runs entirely in your browser.

How it works

Each entry shows the operator, its category and a short description, with an example for the most common ones. The category matters because the same $ name can behave differently depending on where it appears. A query filter, an update document and an aggregation pipeline each use their own operator set:

// query
db.orders.find({ total: { $gt: 100 }, status: { $in: ["paid", "shipped"] } })

// update
db.orders.updateOne({ _id: id }, { $set: { status: "paid" }, $inc: { tries: 1 } })

// aggregation
db.orders.aggregate([
  { $match: { status: "paid" } },
  { $group: { _id: "$customer", spent: { $sum: "$total" } } },
  { $lookup: { from: "users", localField: "_id", foreignField: "_id", as: "user" } }
])

Tips and examples

Put a $match as early as possible in a pipeline so it can use indexes and shrink the document stream before expensive later stages.
Use $expr to compare two fields in the same document inside find().
$elemMatch is required when you need several conditions to hold on the same array element rather than on the array as a whole.
$facet lets you compute several aggregations (e.g. results plus a total count) from one input in a single round trip.