MongoDB Command Cheatsheet

Using the MongoDB Shell

Connecting to MongoDB

Description	Command
Connect to a MongoDB instance	mongo
Connect to a specific database	mongo <database_name>
Connect to a remote MongoDB server	mongo <hostname>:<port>/<database_name>
Connect via mongosh	mongosh
Connect to specific host and port via mongosh	mongosh --host <host> --port <port> --authenticationDatabase admin -u <user> -p <pwd>
Connect via mongosh with connection string	mongosh "mongodb://<user>:<password>@192.168.1.1:27017"
Connect to MongoDB Atlas via mongosh	mongosh "mongodb+srv://cluster-name.abcde.mongodb.net/<dbname>" --apiVersion 1 --username <username>

Database Operations

Description	Command
Show all databases	show dbs
Use a specific database	use <database_name>
Get the current database	db
Drop the current database	db.dropDatabase()

Collection Operations

Description	Command
Show all collections in the current database	show collections
Create a collection	db.createCollection("<collection_name>")
Drop a collection	db.<collection_name>.drop()

CRUD Operations

Create

Description	Command
Insert a document	db.coll.insertOne({name: "Max"})
Insert multiple documents (ordered)	db.coll.insertMany([{name: "Max"}, {name: "Alex"}])
Insert multiple documents (unordered)	db.coll.insertMany([{name: "Max"}, {name: "Alex"}], {ordered: false})
Insert document with current date	db.coll.insertOne({date: ISODate()})
Insert document with write concern	db.coll.insertOne({name: "Max"}, {"writeConcern": {"w": "majority", "wtimeout": 5000}})

Read

Description	Command
Find one document	db.coll.findOne()
Find all documents	db.coll.find()
Find all documents (pretty print)	db.coll.find().pretty()
Find documents with a query	db.coll.find({name: "Max", age: 32})
Find documents with date	db.coll.find({date: ISODate("2020-09-25T13:57:17.180Z")})
Explain query execution stats	db.coll.find({name: "Max", age: 32}).explain("executionStats")
Get distinct values of a field	db.coll.distinct("name")
Count documents with a query	db.coll.countDocuments({age: 32})
Get estimated document count	db.coll.estimatedDocumentCount()

Update

Description	Command
Update a document (set fields)	db.coll.updateOne({"_id": 1}, {$set: {"year": 2016, name: "Max"}})
Update a document (unset fields)	db.coll.updateOne({"_id": 1}, {$unset: {"year": 1}})
Rename a field	db.coll.updateOne({"_id": 1}, {$rename: {"year": "date"}})
Increment a field	db.coll.updateOne({"_id": 1}, {$inc: {"year": 5}})
Multiply a field	db.coll.updateOne({"_id": 1}, {$mul: {price: NumberDecimal("1.25"), qty: 2}})
Set minimum value of a field	db.coll.updateOne({"_id": 1}, {$min: {"imdb": 5}})
Set maximum value of a field	db.coll.updateOne({"_id": 1}, {$max: {"imdb": 8}})
Set current date	db.coll.updateOne({"_id": 1}, {$currentDate: {"lastModified": true}})
Set current date as timestamp	db.coll.updateOne({"_id": 1}, {$currentDate: {"lastModified": {$type: "timestamp"}}})
Array updates (push)	db.coll.updateOne({"_id": 1}, {$push: {"array": 1}})
Array updates (pull)	db.coll.updateOne({"_id": 1}, {$pull: {"array": 1}})
Array updates (addToSet)	db.coll.updateOne({"_id": 1}, {$addToSet: {"array": 2}})
Array updates (pop last element)	db.coll.updateOne({"_id": 1}, {$pop: {"array": 1}})
Array updates (pop first element)	db.coll.updateOne({"_id": 1}, {$pop: {"array": -1}})
Array updates (pullAll)	db.coll.updateOne({"_id": 1}, {$pullAll: {"array": [3, 4, 5]}})
Array updates (push with each)	db.coll.updateOne({"_id": 1}, {$push: {"scores": {$each: [90, 92]}}})
Array updates (push with sort)	db.coll.updateOne({"_id": 2}, {$push: {"scores": {$each: [40, 60], $sort: 1}}})
Update array element	db.coll.updateOne({"_id": 1, "grades": 80}, {$set: {"grades.$": 82}})
Update all array elements	db.coll.updateMany({}, {$inc: {"grades.$[]": 10}})
Update array elements with filter	db.coll.updateMany({}, {$set: {"grades.$[element]": 100}}, {multi: true, arrayFilters: [{"element": {$gte: 100}}]})
Find and update	db.coll.findOneAndUpdate({"name": "Max"}, {$inc: {"points": 5}}, {returnNewDocument: true})
Upsert (update or insert)	db.coll.updateOne({"_id": 1}, {$set: {item: "apple"}, $setOnInsert: {defaultQty: 100}}, {upsert: true})
Replace a document	db.coll.replaceOne({"name": "Max"}, {"firstname": "Maxime", "surname": "Beugnet"})
Update with write concern	db.coll.updateMany({}, {$set: {"x": 1}}, {"writeConcern": {"w": "majority", "wtimeout": 5000}})

Delete

Description	Command
Delete one document	db.coll.deleteOne({name: "Max"})
Delete multiple documents	db.coll.deleteMany({name: "Max"}, {"writeConcern": {"w": "majority", "wtimeout": 5000}})
Delete all documents	db.coll.deleteMany({})
Find and delete	db.coll.findOneAndDelete({"name": "Max"})

Indexing

Description	Command
Create an index on a field	db.<collection_name>.createIndex({<field>: 1})
Create a unique index	db.<collection_name>.createIndex({<field>: 1}, {unique: true})
List all indexes on a collection	db.<collection_name>.getIndexes()
Drop an index	db.<collection_name>.dropIndex("<index_name>")
Hide an index	db.coll.hideIndex("name_1")
Unhide an index	db.coll.unhideIndex("name_1")

Aggregation

Description	Command
Aggregation framework	db.<collection_name>.aggregate([ { $match: { <field>: <value> } }, { $group: { _id: "$<group_field>", total: { $sum: "$<sum_field>" } } }, { $sort: {total: -1} } ])

Backup and Restore

Description	Command
Backup a database	mongodump --db <database_name> --out <backup_directory>
Restore a database	mongorestore --db <database_name> <backup_directory>/<database_name>

User Management

Description	Command
Create a new user	db.createUser({ user: "<username>", pwd: "<password>", roles: [ { role: "<role>", db: "<database>" } ] })
Show users	show users
Drop a user	db.dropUser("<username>")

Server Administration

Description	Command
Server status	db.serverStatus()
Database statistics	db.stats()
Collection statistics	db.<collection_name>.stats()
Current operations	db.currentOp()
Kill an operation	db.killOp(<operation_id>)
Lock the database	db.fsyncLock()
Unlock the database	db.fsyncUnlock()
Get collection names	db.getCollectionNames()
Get collection info	db.getCollectionInfos()
Print collection stats	db.printCollectionStats()
Replication info	db.getReplicationInfo()
Print replication info	db.printReplicationInfo()
Server info	db.hello()
Host info	db.hostInfo()
Shutdown server	db.shutdownServer()
Profiling status	db.getProfilingStatus()
Set profiling level	db.setProfilingLevel(1, 200)
Enable free monitoring	db.enableFreeMonitoring()
Disable free monitoring	db.disableFreeMonitoring()
Get free monitoring status	db.getFreeMonitoringStatus()

Handy Commands

Description	Command
Use admin database	use admin
Create root user	db.createUser({"user": "root", "pwd": passwordPrompt(), "roles": ["root"]})
Drop root user	db.dropUser("root")
Authenticate user	db.auth( "user", passwordPrompt() )
Switch to test database	use test
Get sibling database	db.getSiblingDB("dbname")
Get current operations	db.currentOp()
Kill operation	db.killOp(123)
Get collection stats	db.printCollectionStats()
Get server status	db.serverStatus()
Create a view	db.createView("viewName", "sourceColl", [{$project:{department: 1}}])

Change Streams

Description	Command
Watch for changes	watchCursor = db.coll.watch([ { $match : {"operationType" : "insert" } } ])
Iterate change stream	while (!watchCursor.isExhausted()){ if (watchCursor.hasNext()){ print(tojson(watchCursor.next())); } }

Replica Set

Description	Command
Replica set status	rs.status()
Initiate replica set	rs.initiate({"_id": "RS1", members: [ { _id: 0, host: "mongodb1.net:27017" }, { _id: 1, host: "mongodb2.net:27017" }, { _id: 2, host: "mongodb3.net:27017" }]})
Add a member	rs.add("mongodb4.net:27017")
Add an arbiter	rs.addArb("mongodb5.net:27017")
Remove a member	rs.remove("mongodb1.net:27017")
Get replica set config	rs.conf()
Replica set hello	rs.hello()
Print replication info	rs.printReplicationInfo()
Print secondary replication info	rs.printSecondaryReplicationInfo()
Reconfigure replica set	rs.reconfig(config)
Set read preference	db.getMongo().setReadPref('secondaryPreferred')
Step down primary	rs.stepDown(20, 5)

Sharded Cluster

Description	Command
Print sharding status	db.printShardingStatus()
Sharding status	sh.status()
Add a shard	sh.addShard("rs1/mongodb1.example.net:27017")
Shard a collection	sh.shardCollection("mydb.coll", {zipcode: 1})
Move a chunk	sh.moveChunk("mydb.coll", { zipcode: "53187" }, "shard0019")
Split a chunk at a key	sh.splitAt("mydb.coll", {x: 70})
Split a chunk by find query	sh.splitFind("mydb.coll", {x: 70})
Start balancer	sh.startBalancer()
Stop balancer	sh.stopBalancer()
Disable balancing	sh.disableBalancing("mydb.coll")
Enable balancing	sh.enableBalancing("mydb.coll")
Get balancer state	sh.getBalancerState()
Set balancer state	sh.setBalancerState(true/false)
Is balancer running	sh.isBalancerRunning()
Start auto merger	sh.startAutoMerger()
Stop auto merger	sh.stopAutoMerger()
Enable auto merger	sh.enableAutoMerger()
Disable auto merger	sh.disableAutoMerger()
Update zone key range	sh.updateZoneKeyRange("mydb.coll", {state: "NY", zip: MinKey }, { state: "NY", zip: MaxKey }, "NY")
Remove range from zone	sh.removeRangeFromZone("mydb.coll", {state: "NY", zip: MinKey }, { state: "NY", zip: MaxKey })
Add shard to zone	sh.addShardToZone("shard0000", "NYC")
Remove shard from zone	sh.removeShardFromZone("shard0000", "NYC")