MongoDB Basics Explained for Beginners

// One document inside the "products" collection.
// Notice the nesting — no JOIN needed to read the whole product.

{
  "_id": ObjectId("66d4f1c2a8b3e4f5d6c7b8a9"),
  "name": "Wireless Mouse",
  "price": 799,
  "category": "electronics",
  "tags": ["wireless", "usb", "ergonomic"],
  "specs": {
    "connectivity": "2.4 GHz",
    "battery": "AA",
    "buttons": 3
  },
  "inStock": true,
  "createdAt": ISODate("2026-09-01T10:15:00Z")
}

// _id is the primary key — MongoDB generates it automatically
// if you do not supply one. It is unique per collection.

// A user document with an embedded address object.
// Embedding keeps reads fast: one find() returns the whole user.

{
  "_id": ObjectId("66d4f1c2a8b3e4f5d6c7b8aa"),
  "name": "Priya Sharma",
  "email": "priya@example.com",
  "address": {
    "line1": "12 MG Road",
    "city": "Bengaluru",
    "state": "Karnataka",
    "pincode": "560001"
  },
  "roles": ["customer", "reviewer"],
  "createdAt": ISODate("2026-08-14T06:30:00Z")
}

// You can query into nested fields with dot notation:
//   db.users.find({ "address.city": "Bengaluru" })
// You can also index them:
//   db.users.createIndex({ "address.city": 1 })

// Documents in the same collection do NOT need the same shape.
// This is valid — and often the right choice in MongoDB.

// Document 1: a product with a discount
{
  "_id": ObjectId("...01"),
  "name": "Wireless Mouse",
  "price": 799,
  "discount": { "type": "percent", "value": 10 }
}

// Document 2: a product with warranty info instead
{
  "_id": ObjectId("...02"),
  "name": "Mechanical Keyboard",
  "price": 2499,
  "warranty": { "months": 24, "provider": "BrandCare" }
}

// Document 3: a product with both
{
  "_id": ObjectId("...03"),
  "name": "USB-C Hub",
  "price": 1499,
  "discount": { "type": "flat", "value": 200 },
  "warranty": { "months": 12, "provider": "HubCare" }
}

// This is flexibility, not chaos — your application code decides
// which fields are required for which kinds of product.

// MongoDB CRUD — the four operations you will use every day.
// Run these in mongosh against a local database.

// Use (or create) a database and collection
use shop

// CREATE — insert a single document
db.products.insertOne({
  name: "Wireless Mouse",
  price: 799,
  category: "electronics",
  tags: ["wireless", "usb"],
  inStock: true,
  createdAt: new Date()
})

// CREATE — insert many documents at once
db.products.insertMany([
  { name: "Mechanical Keyboard", price: 2499, category: "electronics", inStock: true },
  { name: "USB-C Hub", price: 1499, category: "electronics", inStock: false }
])

// READ — find documents that match a filter
db.products.find({ category: "electronics" })

// READ — find a single document
db.products.findOne({ name: "Wireless Mouse" })

// UPDATE — change one field on one document
db.products.updateOne(
  { name: "Wireless Mouse" },
  { $set: { price: 699 } }
)

// UPDATE — increment a numeric field
db.products.updateOne(
  { name: "Mechanical Keyboard" },
  { $inc: { price: 100 } }
)

// DELETE — remove one document
db.products.deleteOne({ name: "USB-C Hub" })

// DELETE — remove many documents
db.products.deleteMany({ category: "electronics", inStock: false })

// Query operators, projections, and sort — the tools you need
// to ask real questions of your data.

// Comparison operators
db.products.find({ price: { $gt: 500 } })
db.products.find({ price: { $gte: 500, $lte: 2000 } })
db.products.find({ category: { $in: ["electronics", "accessories"] } })

// Logical operators
db.products.find({
  $and: [
    { category: "electronics" },
    { inStock: true }
  ]
})

db.products.find({
  $or: [
    { price: { $lt: 500 } },
    { inStock: false }
  ]
})

// Existence and type
db.products.find({ tags: { $exists: true } })
db.products.find({ price: { $type: "number" } })

// Projection — return only the fields you need
db.products.find(
  { category: "electronics" },
  { name: 1, price: 1, _id: 0 }
)

// Sort, limit, skip — pagination
db.products
  .find({ category: "electronics" })
  .sort({ price: -1 })
  .limit(10)
  .skip(0)

// Count matching documents
db.products.countDocuments({ inStock: true })

// Distinct values — useful for filters in a UI
db.products.distinct("category")

// Indexes and explain — how to make queries fast and prove it.

// See what indexes already exist
db.products.getIndexes()

// Single-field index on a field you filter or sort by
db.products.createIndex({ category: 1 })

// Compound index — matches queries that filter on both fields
db.products.createIndex({ category: 1, price: -1 })

// Unique index — enforce uniqueness
db.users.createIndex({ email: 1 }, { unique: true })

// TTL index — auto-delete old sessions
db.sessions.createIndex(
  { createdAt: 1 },
  { expireAfterSeconds: 3600 }
)

// Text index — basic full-text search
db.products.createIndex({ name: "text", description: "text" })
db.products.find({ $text: { $search: "wireless keyboard" } })

// explain() — check whether the query uses the index
db.products
  .find({ category: "electronics", price: { $gt: 500 } })
  .explain("executionStats")

// Look for:
//   stage: "IXSCAN"   — index used (good)
//   stage: "COLLSCAN" — full collection scan (slow)
//   totalDocsExamined — should be close to nReturned

// Rule of thumb: index every field you filter or sort by
// in production queries. Do not index everything — writes pay
// the cost of every index you add.