MongoDB Complete Master Manual

// Shell version check mongosh --version // Connect to default server mongosh "mongodb://localhost:27017" // Run daemon manually mongod --dbpath /path/to/data

show dbs use college db show collections db.getName() db.stats() db.version() db.serverStatus() db.getCollectionNames() db.getCollectionInfos()

use college db.createCollection("students") show collections // Capped Collection Example db.createCollection("logs", { capped: true, size: 100000 })

// Single insert db.students.insertOne({ name: "Aman", age: 22, course: "MCA" }) // Batch insert db.students.insertMany([ { name: "Aman", age: 22, course: "MCA" }, { name: "Riya", age: 21, course: "BCA" } ]) // Unordered batch insert db.students.insertMany( [{ name: "A" }, { name: "B" }], { ordered: false } )

db.students.find() db.students.find({ age: 22 }) db.students.findOne({ name: "Aman" }) db.students.find({ age: { $gte: 18 } }) db.students.find( { course: "MCA" }, { name: 1, age: 1, _id: 0 } )

// AND — Implicit db.students.find({ age: { $gte: 18 }, course: "MCA" }) // OR db.students.find({ $or: [ { city: "Ludhiana" }, { city: "Chandigarh" } ] }) // AND — Explicit db.students.find({ $and: [ { age: { $gte: 18 } }, { course: "MCA" } ] }) // NOR db.students.find({ $nor: [ { city: "Delhi" }, { city: "Mumbai" } ] }) // NOT db.students.find({ age: { $not: { $gt: 30 } } })

db.students.find({ phone: { $exists: true } }) db.students.find({ phone: { $exists: false } }) db.students.find({ age: { $type: "int" } })

// Matches both null value and missing field db.students.find({ phone: null }) // Matches strictly missing field db.students.find({ phone: { $exists: false } })

// Starts with 'A' db.students.find({ name: { $regex: "^A" } }) // Case-insensitive regex matching "an" db.students.find({ name: { $regex: "an", $options: "i" } })

// Contains element db.students.find({ skills: "Python" }) // Contains ALL elements db.students.find({ skills: { $all: ["Python", "MongoDB"] } }) // Array size check db.students.find({ skills: { $size: 2 } }) // Element match condition db.students.find({ skills: { $elemMatch: { $eq: "Python" } } })

db.students.find({ "address.city": "Ludhiana" }) db.students.find({ "address.pin": { $gte: 141000 } })

// Sorting (-1 descending, 1 ascending) db.students.find().sort({ age: -1 }) // Pagination limits db.students.find().limit(10) db.students.find().skip(20) // Document counting & distinct values db.students.countDocuments({ course: "MCA" }) db.students.distinct("city") // Iterate cursor with forEach db.students.find().forEach(x => print(x))

db.students.updateOne( { name: "Aman" }, { $set: { city: "Ludhiana" } } ) db.students.updateMany( { course: "MCA" }, { $inc: { age: 1 } } ) db.students.replaceOne( { name: "Aman" }, { name: "Aman", age: 23, course: "MCA" } )

db.students.updateOne( { email: "aman@example.com" }, { $set: { name: "Aman", age: 22 } }, { upsert: true } )

db.students.deleteOne({ name: "Aman" }) db.students.deleteMany({ course: "BCA" })

db.students.findOneAndUpdate( { email: "aman@example.com" }, { $set: { verified: true } }, { returnDocument: "after" } ) db.students.findOneAndDelete({ email: "old@example.com" }) db.students.findOneAndReplace( { email: "aman@example.com" }, { email: "aman@example.com", name: "Aman", age: 23 } )

db.students.bulkWrite([ { insertOne: { document: { name: "A" } } }, { updateOne: { filter: { name: "A" }, update: { $set: { age: 22 } } } }, { deleteOne: { filter: { name: "Old" } } } ])

db.runCommand({ hello: 1 }) db.adminCommand({ serverStatus: 1 }) db.runCommand({ ping: 1 })

db.createCollection("students") db.getCollection("students") db.students.renameCollection("learners") db.students.drop() db.dropDatabase()

// Create ascending index db.students.createIndex({ email: 1 }) // Inspect indexes db.students.getIndexes() // Drop specific index db.students.dropIndex({ email: 1 }) // Drop all non-id indexes db.students.dropIndexes()

db.students.createIndex({ course: 1, age: -1 })

// Unique Index db.users.createIndex({ email: 1 }, { unique: true }) // Sparse Index db.users.createIndex({ phone: 1 }, { sparse: true }) // Partial Index db.users.createIndex( { email: 1 }, { unique: true, partialFilterExpression: { active: true } } )

db.sessions.createIndex( { createdAt: 1 }, { expireAfterSeconds: 3600 } )

db.students.getIndexes() db.students.aggregate([ { $indexStats: {} } ]) db.students.find({ email: "aman@example.com" }).explain("executionStats")

db.students.find({ course: "MCA" }).hint({ course: 1 })

db.collection.aggregate([ { stage1: { /* ... */ } }, { stage2: { /* ... */ } }, { stage3: { /* ... */ } } ])

db.orders.aggregate([ { $match: { status: "paid" } }, { $project: { customer: 1, amount: 1, _id: 0 } } ])

db.orders.aggregate([ { $group: { _id: "$customer", totalSales: { $sum: "$amount" }, avgOrder: { $avg: "$amount" }, orders: { $sum: 1 } } } ])

db.orders.aggregate([ { $sort: { amount: -1 } }, { $limit: 10 } ])

db.orders.aggregate([ { $unwind: "$items" }, { $project: { customer: 1, product: "$items.product", qty: "$items.qty" } } ])

db.orders.aggregate([ { $lookup: { from: "customers", localField: "customerId", foreignField: "_id", as: "customer" } } ])

db.products.aggregate([ { $facet: { byCategory: [ { $group: { _id: "$category", count: { $sum: 1 } } } ], topProducts: [ { $sort: { sales: -1 } }, { $limit: 5 } ] } } ])

db.orders.aggregate([ { $project: { customer: 1, total: { $multiply: ["$price", "$quantity"] }, year: { $year: "$createdAt" } } } ])

db.orders.aggregate([ { $group: { _id: "$customer", total: { $sum: "$amount" } } }, { $merge: { into: "customer_totals" } } ])

const session = db.getMongo().startSession(); const sdb = session.getDatabase("college"); try { session.startTransaction(); sdb.students.updateOne( { name: "Aman" }, { $inc: { balance: -100 } } ); sdb.fees.updateOne( { student: "Aman" }, { $inc: { paid: 100 } } ); session.commitTransaction(); } catch (e) { session.abortTransaction(); } finally { session.endSession(); }

rs.status() rs.conf() rs.isMaster() // Legacy helper; use hello command for current server discovery db.adminCommand({ hello: 1 })

sh.enableSharding("college") sh.shardCollection("college.students", { studentId: "hashed" }) sh.status() sh.listShards()

use admin db.createUser({ user: "appUser", pwd: "CHANGE_ME", roles: [ { role: "readWrite", db: "college" } ] }) db.getUsers() db.grantRolesToUser("appUser", [{ role: "read", db: "reporting" }]) db.revokeRolesFromUser("appUser", [{ role: "read", db: "reporting" }]) db.dropUser("appUser")

// Shell connection with auth credentials mongosh --host localhost --port 27017 --username appUser --authenticationDatabase admin // URI Connection mongosh "mongodb://appUser:PASSWORD@localhost:27017/college?authSource=admin"

// Standard URI mongodb://username:password@host:27017/database?authSource=admin // DNS SRV Seedlist Connection (Atlas / Cloud) mongodb+srv://username:password@cluster.example.mongodb.net/database

// Dump database to folder mongodump --uri="mongodb://localhost:27017/college" --out=./backup // Restore database from folder mongorestore --uri="mongodb://localhost:27017/college" ./backup/college // Dump database to archive file mongodump --uri="mongodb://localhost:27017/college" --archive=college.archive // Restore database from archive file mongorestore --uri="mongodb://localhost:27017/college" --archive=college.archive

mongoexport --uri="mongodb://localhost:27017/college" --collection=students --out=students.json mongoimport --uri="mongodb://localhost:27017/college" --collection=students --file=students.json --jsonArray

from pymongo import MongoClient client = MongoClient("mongodb://localhost:27017") db = client["college"] students = db["students"] // Insert students.insert_one({"name": "Aman", "age": 22, "course": "MCA"}) // Read student = students.find_one({"name": "Aman"}) print(student) // Update students.update_one({"name": "Aman"}, {"$set": {"city": "Ludhiana"}}) // Delete students.delete_one({"name": "Aman"}) client.close()

pipeline = [ {"$match": {"course": "MCA"}}, {"$group": {"_id": "$city", "count": {"$sum": 1}}}, {"$sort": {"count": -1}} ] for row in students.aggregate(pipeline): print(row)

const { MongoClient } = require("mongodb"); const client = new MongoClient(process.env.MONGO_URI); async function main() { await client.connect(); const db = client.db("college"); const students = db.collection("students"); await students.insertOne({ name: "Aman", age: 22 }); console.log(await students.find({}).toArray()); await students.updateOne({ name: "Aman" }, { $set: { city: "Ludhiana" } }); await students.deleteOne({ name: "Aman" }); await client.close(); } main().catch(console.error);

from fastapi import FastAPI from pymongo import MongoClient import os app = FastAPI() client = MongoClient(os.environ["MONGO_URI"]) db = client["college"] students = db["students"] @app.post("/students") def create_student(data: dict): result = students.insert_one(data) return {"id": str(result.inserted_id)} @app.get("/students") def get_students(): return list(students.find({}, {"_id": 0})) @app.delete("/students/{name}") def delete_student(name: str): result = students.delete_one({"name": name}) return {"deleted": result.deleted_count}

from flask import Flask, request, jsonify from pymongo import MongoClient import os app = Flask(__name__) client = MongoClient(os.environ["MONGO_URI"]) db = client["college"] @app.post("/students") def create_student(): data = request.get_json() result = db.students.insert_one(data) return jsonify({"id": str(result.inserted_id)}), 201

const { ObjectId } = require("mongodb"); const id = new ObjectId("507f1f77bcf86cd799439011"); const student = await students.findOne({ _id: id });

// Exists db.users.find({ email: { $exists: true } }) // Range filter db.products.find({ price: { $gte: 500, $lte: 2000 } }) // Nested object field filter db.users.find({ "address.city": "Ludhiana" }) // Array element filter db.users.find({ skills: "Python" }) // Multiple conditions db.users.find({ age: { $gte: 18 }, active: true })

// 1. Simple Skip/Limit (For small datasets) db.products.find({}) .sort({ _id: 1 }) .skip(20) .limit(10) // 2. Cursor/Range-Based Pagination (High performance on large collections) const lastId = ObjectId("..."); db.products.find({ _id: { $gt: lastId } }) .sort({ _id: 1 }) .limit(10)

{ _id: ObjectId("..."), customerId: ObjectId("..."), status: "paid", items: [ { productId: ObjectId("..."), name: "Shoes", qty: 2, price: 1500 }, { productId: ObjectId("..."), name: "Belt", qty: 1, price: 500 } ], total: 3500, createdAt: ISODate("2026-10-05T10:00:00Z") }

db.createCollection("temperatures", { timeseries: { timeField: "timestamp", metaField: "sensor", granularity: "minutes" } }) db.temperatures.insertOne({ timestamp: new Date(), sensor: { id: "S01", room: "A" }, temperature: 28.4 })

const changeStream = db.collection("orders").watch(); changeStream.on("change", change => { console.log(change); });

Client -> mongos router -> Shard 1 (Replica Set) -> Shard 2 (Replica Set) -> Shard 3 (Replica Set) Config Server Replica Set

Application -> Primary (Writes) -> Replication -> Secondary 1 (Reads) -> Secondary 2 (Reads)

show dbs use college db show collections db.createCollection("students") db.students.insertOne({...}) db.students.insertMany([...]) db.students.find() db.students.findOne({...}) db.students.updateOne({...}, {...}) db.students.updateMany({...}, {...}) db.students.replaceOne({...}, {...}) db.students.deleteOne({...}) db.students.deleteMany({...}) db.students.createIndex({...}) db.students.getIndexes() db.students.aggregate([...]) db.stats() db.runCommand({ping:1}) db.adminCommand({serverStatus:1})