MongoDB

Connection

Connecting to MongoDB

Database

Database operations

CRUD

Insert, find, update, delete

10commands

Query

Query operators

Indexes

Index management

6commands

Aggregation

Aggregation pipeline

Backup/Restore

mongodump & mongorestore

Change Streams

Real-time change monitoring

Transactions

Multi-document ACID transactions

Time Series

Time series collections

Performance

Performance monitoring & ops

Users & Roles

User management, authentication & authorization

16commands

Run MongoDB with Docker

$ docker run -d -p 27017:27017 --name mongodb mongo:latest

Start MongoDB server in a Docker container on port 27017

Connect with mongosh

$ docker exec -it mongodb mongosh

Open interactive MongoDB shell in the running container

Show databases

$ mongosh --eval 'show dbs'

List all databases in MongoDB

Connect to MongoDB

$ mongosh mongodb://localhost:27017

Connect to local MongoDB instance.

Connect with auth

$ mongosh mongodb://user:pass@localhost:27017/mydb

Connect with authentication.

Connect to Atlas

$ mongosh "mongodb+srv://cluster.mongodb.net/mydb" --apiVersion 1 --username admin

Connect to MongoDB Atlas cluster.

Execute and exit

$ mongosh --eval "db.version()" mydb

Run command and exit.

Run script file

$ mongosh mydb script.js

Execute JavaScript file.

Show databases

$ show dbs

List all databases.

Use database

$ use mydb

Switch to database (creates if not exists).

Current database

$ db

Show current database.

Show collections

$ show collections

List collections in current database.

Create collection

$ db.createCollection("users")

Create a new collection.

Drop collection

$ db.users.drop()

Delete a collection.

Drop database

$ db.dropDatabase()

Delete current database.

Database stats

$ db.stats()

Show database statistics.

Insert one

$ db.users.insertOne({ name: "John", age: 30 })

Insert a single document.

Insert many

$ db.users.insertMany([{ name: "A" }, { name: "B" }])

Insert multiple documents.

Find all

$ db.users.find()

Retrieve all documents.

Find with filter

$ db.users.find({ age: { $gt: 25 } })

Find documents matching criteria.

Find one

$ db.users.findOne({ name: "John" })

Retrieve first matching document.

Update one

$ db.users.updateOne({ name: "John" }, { $set: { age: 31 } })

Update first matching document.

Update many

$ db.users.updateMany({ active: false }, { $set: { status: "inactive" } })

Update all matching documents.

Delete one

$ db.users.deleteOne({ name: "John" })

Delete first matching document.

Delete many

$ db.users.deleteMany({ status: "inactive" })

Delete all matching documents.

Replace one

$ db.users.replaceOne({ name: "John" }, { name: "John", age: 32, email: "john@ex.com" })

Replace entire document.

Comparison operators

$ db.users.find({ age: { $gte: 18, $lte: 65 } })

Use $gt, $gte, $lt, $lte, $eq, $ne.

Logical AND

$ db.users.find({ $and: [{ age: { $gt: 20 } }, { status: "active" }] })

Match all conditions.

Logical OR

$ db.users.find({ $or: [{ age: { $lt: 20 } }, { status: "vip" }] })

Match any condition.

In array

$ db.users.find({ role: { $in: ["admin", "moderator"] } })

Match any value in array.

Regex search

$ db.users.find({ name: { $regex: /^john/i } })

Pattern matching with regex.

Field exists

$ db.users.find({ email: { $exists: true } })

Check if field exists.

Projection

$ db.users.find({}, { name: 1, email: 1, _id: 0 })

Select specific fields to return.

Sort and limit

$ db.users.find().sort({ age: -1 }).limit(10)

Sort descending and limit results.

Create index

$ db.users.createIndex({ email: 1 })

Create ascending index on field.

Unique index

$ db.users.createIndex({ email: 1 }, { unique: true })

Create unique constraint index.

Compound index

$ db.users.createIndex({ lastName: 1, firstName: 1 })

Create index on multiple fields.

Text index

$ db.articles.createIndex({ content: "text" })

Create full-text search index.

List indexes

$ db.users.getIndexes()

Show all indexes on collection.

Drop index

$ db.users.dropIndex("email_1")

Remove an index by name.

Basic aggregation

$ db.orders.aggregate([{ $match: { status: "completed" } }, { $group: { _id: "$customerId", total: { $sum: "$amount" } } }])

Match and group with sum.

Count by group

$ db.users.aggregate([{ $group: { _id: "$status", count: { $sum: 1 } } }])

Count documents per group.

Lookup (join)

$ db.orders.aggregate([{ $lookup: { from: "users", localField: "userId", foreignField: "_id", as: "user" } }])

Join with another collection.

Unwind array

$ db.orders.aggregate([{ $unwind: "$items" }, { $group: { _id: "$items.product", total: { $sum: "$items.qty" } } }])

Flatten array and aggregate.

Project fields

$ db.users.aggregate([{ $project: { fullName: { $concat: ["$firstName", " ", "$lastName"] }, age: 1 } }])

Transform document structure.

Dump database

$ mongodump --db mydb --out /backup

Export database to BSON files.

Dump collection

$ mongodump --db mydb --collection users --out /backup

Export specific collection.

Dump with compression

$ mongodump --db mydb --gzip --archive=backup.gz

Export as compressed archive.

Restore database

$ mongorestore --db mydb /backup/mydb

Import from BSON dump.

Restore from archive

$ mongorestore --gzip --archive=backup.gz

Restore from compressed archive.

Export to JSON

$ mongoexport --db mydb --collection users --out users.json

Export collection to JSON file.

Import from JSON

$ mongoimport --db mydb --collection users --file users.json

Import from JSON file.

Import CSV

$ mongoimport --db mydb --collection users --type csv --headerline --file users.csv

Import from CSV with headers.

Watch collection changes

$ db.collection.watch()

Monitor real-time changes to a collection.

Watch database changes

$ db.watch()

Monitor all changes across entire database.

Filtered change stream

$ db.collection.watch([{$match: {operationType: 'insert'}}])

Watch only insert operations on collection.

Close change stream

$ changeStream.close()

Close active change stream connection.

Start session

$ session = db.getMongo().startSession()

Initialize client session for transactions.

Begin transaction

$ session.startTransaction()

Start multi-document ACID transaction.

Commit transaction

$ session.commitTransaction()

Persist all transaction changes.

Abort transaction

$ session.abortTransaction()

Rollback transaction changes.

Create time series collection

$ db.createCollection("metrics", {timeseries: {timeField: "timestamp", metaField: "metadata"}})

Create optimized collection for time-stamped data.

Collection statistics

$ db.collection.stats()

View detailed collection storage and index info.

Validate collection

$ db.collection.validate({full: true})

Perform full integrity check on collection.

Total index size

$ db.collection.totalIndexSize()

Calculate total storage used by all indexes.

Current operations

$ db.currentOp()

Show all currently running database operations.

Kill operation

$ db.killOp(<opid>)

Terminate a long-running or stuck operation.

Discussion

Loading comments...

MongoDB

MongoDB shell commands for CRUD operations, aggregation pipelines, indexing, and database administration.

83 commands

Browse by Topic

Getting Started

Quick setup and installation

Connection

Connecting to MongoDB

Database

Database operations

CRUD

Insert, find, update, delete

10commands

Query

Query operators

Indexes

Index management

6commands

Aggregation

Aggregation pipeline

Backup/Restore

mongodump & mongorestore

Change Streams

Real-time change monitoring

Transactions

Multi-document ACID transactions

Time Series

Time series collections

Performance

Performance monitoring & ops