Capstok — learn by doing

Why this matters

MongoDB's query language is built around composable operator objects. Understanding the operator taxonomy — comparison ( $eq,$ ne, $gt,$ lt, $in,$ nin), logical ( $and,$ or, $not), element ($ exists, $t y p e) — l e t s y o u e x p r e s s c o m p l e x f i l t e r s w i t h o u t p u l l i n g d a t a i n t o a p p l i c a t i o n c o d e a n d f i l t e r i n g t h e r e, w h i c h i s a c o m m o n p e r f o r m a n c e a n t i - p a t t e r n . E v e r y f i l t e r t h a t r u n s s e r v e r - s i d e s a v e s a n e t w o r k r o u$ regex operator deserves special attention because unanchored regex patterns always do a full collection scan regardless of indexes.

Demo

Query a products collection using comparison, logical, and regex operators.

Try it yourself

Query for products where price is NOT in [9.99, 49.99] using $nin. Verify the count matches documents outside those exact prices.
Add a field inStock: false to the Doohickey. Query { inStock: { $ne: true } } — confirm it returns both documents missing the field AND the one explicitly set to false. Explain why.
Create an index on name. Run { name: /widget/i } (unanchored) and { name: /^Widget/ } (anchored) through explain('executionStats'). Note which uses the index and which does a COLLSCAN.

Prompt your AI

Use these three in order. Each builds on the one before.

1. Basics & terminology

List MongoDB's comparison query operators ($eq, $ne, $gt, $gte, $lt, $lte, $in, $nin) and give a one-line use case for each.

2. Why it works (the mechanism)

Explain how MongoDB evaluates a compound filter like `{ tags: { $in: [...] }, price: { $gt: 5 } }`. Does it short-circuit? In what order are conditions checked relative to index usage?

3. Advanced — application & what's next

I need to query documents where an embedded array field contains at least two specific values simultaneously — e.g. tags contains both 'sale' AND 'new'. What operator do I use and how does MongoDB evaluate it?

References

n

d

-

t

r

i

p

a

n

d

l

e

t

s

t

h

e

q

u

e

r

y

p

l

a

n

n

e

r

u

s

e

a

n

i

n

d

e

x

.

T

h

e

type) — lets you express complex filters without pulling data into application code and filtering there, which is a common performance anti-pattern. Every filter that runs server-side saves a network round-trip and lets the query planner use an index. The

package main

import (
	"context"; "fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

func main() {
	client, _ := mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:27017"))
	col := client.Database("demo").Collection("products")

	// Seed
	col.InsertMany(context.TODO(), []interface{}{
		bson.D{{"name", "Widget Pro"}, {"price", 49.99}, {"tags", bson.A{"sale", "new"}}},
		bson.D{{"name", "Gadget"}, {"price", 99.00}, {"tags", bson.A{"new"}}},
		bson.D{{"name", "Doohickey"}, {"price", 9.99}, {"tags", bson.A{"clearance"}}},
	})

	// $in + $gt
	filter := bson.D{
		{"tags", bson.D{{"$in", bson.A{"sale", "clearance"}}}},
		{"price", bson.D{{"$gt", 5.0}}},
	}
	cursor, _ := col.Find(context.TODO(), filter)
	var results []bson.M
	cursor.All(context.TODO(), &results)
	for _, r := range results { fmt.Println(r["name"], r["price"]) }
}

Run: go run main.go

Filtering with operators: $eq, $gt, $in, $regex