MongoDB mongosh Cheat Sheet

This cheat sheet has quick reference commands for mongosh to get you connected and running CRUD operations as quickly as possible.

Note

This cheat sheet includes common MongoDB commands, but is not comprehensive. See Database Commands and mongosh Methods for full lists.

Connect and Authenticate

Connect

// Omit password if you want to prompt for it
mongosh --host <host> --port <port> --authenticationDatabase admin -u <user> -p <pwd>
mongosh "mongodb://<user>:<password>@192.168.1.1:27017"
mongosh "mongodb://192.168.1.1:27017"
mongosh "mongodb+srv://cluster-name.abcde.mongodb.net/<dbname>" --apiVersion
1 --username <username> # MongoDB Atlas

Connection Information

db.getMongo()               // get connection object
db.getMongo().getDBs()      // list databases
db.hello()
db.runCommand({ping: 1})    // test connection
db.listCommands()
db.adminCommand({buildInfo: 1})  // MongoDB build information

Create User and Authenticate

use admin
// Create, drop, or authenticating users
db.createUser({"user": "root", "pwd": passwordPrompt(), "roles": ["root"]})
db.dropUser("root")
db.auth( "user", passwordPrompt() )

Common Helpers

Show Databases

show dbs
db // prints the current database

Switch Database

use <database_name>

Show Collections

show collections

Run JavaScript File

load("myScript.js")

CRUD Operations

Create

db.coll.insertOne({name: "Max"})
db.coll.insertMany([{name: "Max"}, {name:"Alex"}]) // ordered bulk insert
db.coll.insertMany([{name: "Max"}, {name:"Alex"}], {ordered: false}) // unordered bulk insert
db.coll.insertOne({date: ISODate()})
db.coll.insertOne({name: "Max"}, {"writeConcern": {"w": "majority", "wtimeout": 5000}})

Read

Basic Find Operations

db.coll.findOne() // returns a single document
db.coll.find() // returns a cursor that displays 20 results, use "it" to display more
db.coll.find().pretty()
db.coll.find({name: "Max", age: 32}) // implicit logical "AND".
db.coll.find({date: ISODate("2020-09-25T13:57:17.180Z")})
db.coll.find({name: "Max", age: 32}).explain("executionStats") // or "queryPlanner" or "allPlansExecution"
db.coll.distinct("name")

Count Operations

// Count
db.coll.countDocuments({age: 32}) // $count aggregation alias that returns an accurate count
db.coll.estimatedDocumentCount() // uses collection metadata to estimate the document count

Comparison Operators

// Comparison
db.coll.find({"year": {$gt: 1970}})
db.coll.find({"year": {$gte: 1970}})
db.coll.find({"year": {$lt: 1970}})
db.coll.find({"year": {$lte: 1970}})
db.coll.find({"year": {$ne: 1970}})
db.coll.find({"year": {$in: [1958, 1959]}})
db.coll.find({"year": {$nin: [1958, 1959]}})

Logical Operators

// Logical
db.coll.find({name:{$not: {$eq: "Max"}}})
db.coll.find({$or: [{"year" : 1958}, {"year" : 1959}]})
db.coll.find({$nor: [{price: 1.99}, {sale: true}]})
db.coll.find({
   $and: [
      {$or: [{qty: {$lt :10}}, {qty :{$gt: 50}}]},
      {$or: [{sale: true}, {price: {$lt: 5 }}]}
   ]
})

Element Operators

// Element
db.coll.find({name: {$exists: true}})
db.coll.find({"zipCode": {$type: 2 }})
db.coll.find({"zipCode": {$type: "string"}})

Aggregation Pipeline

// Aggregation Pipeline
db.coll.aggregate([
   {$match: {status: "A"}},
   {$group: {_id: "$cust_id", total: {$sum: "$amount"}}},
   {$sort: {total: -1}}
])

Text Search

// Create text index for search
db.coll.createIndex({ title: "text", content: "text" })
// Basic text search
db.coll.find({$text: {$search: "cake"}})
// Text search queries
db.coll.find({ $text: { $search: "mongodb database" } })
db.coll.find({ $text: { $search: "\"exact phrase\"" } })
db.coll.find({ $text: { $search: "mongodb -database" } })  // exclude "database"
// Text search with scores
db.coll.find({$text: {$search: "cake"}}, {score: {$meta: "textScore"}}).sort({score: {$meta: "textScore"}})

Geospatial Queries

// Create geospatial indexes
db.places.createIndex({ location: "2dsphere" })  // For GeoJSON
db.places.createIndex({ location: "2d" })        // For legacy coordinates
// Find locations near a point
db.places.find({
   location: {
      $near: {
         $geometry: { type: "Point", coordinates: [-73.9857, 40.7484] },
         $maxDistance: 1000  // meters
      }
   }
})
// Find locations within a polygon
db.places.find({
   location: {
      $geoWithin: {
         $geometry: {
            type: "Polygon",
            coordinates: [[
               [-74.0059, 40.7128],
               [-74.0059, 40.7589],
               [-73.9352, 40.7589],
               [-73.9352, 40.7128],
               [-74.0059, 40.7128]
            ]]
         }
      }
   }
})

Regular Expressions

// Regex
db.coll.find({name: /^Max/}) // regex: starts by letter "M"
db.coll.find({name: /^Max$/i}) // regex case insensitive

Array Operations

// Array
db.coll.find({tags: {$all: ["Realm", "Charts"]}})
db.coll.find({field: {$size: 2}}) // can't be indexed, so instead store the size of the array & update it
db.coll.find({results: {$elemMatch: {product: "xyz", score: {$gte: 8}}}})

Projections

// Projections
db.coll.find({"x": 1}, {"actors": 1}) // actors + _id
db.coll.find({"x": 1}, {"actors": 1, "_id": 0}) // actors
db.coll.find({"x": 1}, {"actors": 0, "summary": 0}) // all but "actors" and "summary"

Sort, Skip, Limit

// Sort, skip, limit
db.coll.find({}).sort({"year": 1, "rating": -1}).skip(10).limit(3)

Read Concern

// Read Concern
db.coll.find().readConcern("majority")

Update

Basic Update Operations

db.coll.updateOne({"_id": 1}, {$set: {"year": 2016, name: "Max"}})
db.coll.updateOne({"_id": 1}, {$unset: {"year": 1}})
db.coll.updateOne({"_id": 1}, {$rename: {"year": "date"} })
db.coll.updateOne({"_id": 1}, {$inc: {"year": 5}})
db.coll.updateOne({"_id": 1}, {$mul: {price: NumberDecimal("1.25"), qty: 2}})
db.coll.updateOne({"_id": 1}, {$min: {"imdb": 5}})
db.coll.updateOne({"_id": 1}, {$max: {"imdb": 8}})
db.coll.updateOne({"_id": 1}, {$currentDate: {"lastModified": true}})
db.coll.updateOne({"_id": 1}, {$currentDate: {"lastModified": {$type: "timestamp"}}})

Array Update Operations

// Array
db.coll.updateOne({"_id": 1}, {$push :{"array": 1}})
db.coll.updateOne({"_id": 1}, {$pull :{"array": 1}})
db.coll.updateOne({"_id": 1}, {$addToSet :{"array": 2}})
db.coll.updateOne({"_id": 1}, {$pop: {"array": 1}}) // last element
db.coll.updateOne({"_id": 1}, {$pop: {"array": -1}}) // first element
db.coll.updateOne({"_id": 1}, {$pullAll: {"array" :[3, 4, 5]}})
db.coll.updateOne({"_id": 1}, {$push: {"scores": {$each: [90, 92]}}})
db.coll.updateOne({"_id": 2}, {$push: {"scores": {$each: [40, 60], $sort: 1}}}) // array sorted
db.coll.updateOne({"_id": 1, "grades": 80}, {$set: {"grades.$": 82}})
db.coll.updateMany({}, {$inc: {"grades.$[]": 10}})
db.coll.updateMany({}, {$set: {"grades.$[element]": 100}}, {multi: true, arrayFilters: [{"element": {$gte: 100}}]})

FindOneAndUpdate

// FindOneAndUpdate
db.coll.findOneAndUpdate({"name": "Max"}, {$inc: {"points": 5}}, {returnNewDocument: true})

Upsert

// Upsert
db.coll.updateOne({"_id": 1}, {$set: {item: "apple"}, $setOnInsert: {defaultQty: 100}}, {upsert: true})

Replace

// Replace
db.coll.replaceOne({"name": "Max"}, {"firstname": "Maxime", "surname": "Beugnet"})

Write Concern

// Write concern
db.coll.updateMany({}, {$set: {"x": 1}}, {"writeConcern": {"w": "majority", "wtimeout": 5000}})

Batch and Bulk Operations

// Update many documents efficiently
db.coll.updateMany({status: "pending"}, {$set: {status: "processed"}})
// Delete many documents
db.coll.deleteMany({status: "old"})
// Insert many documents efficiently
db.coll.insertMany([
   {name: "user1", status: "active"},
   {name: "user2", status: "active"},
   {name: "user3", status: "active"}
])
// Bulk operation for mixed insert, update, and delete operations
// Ordered by default, executed serially. If unordered, MongoDB
// executes operations in parallel.
db.coll.bulkWrite([
   { insertOne: { document: { name: "Alice", age: 30 } } },
   { updateOne: { filter: { name: "Bob" }, update: { $set: { age: 25 } } } },
   { deleteOne: { filter: { name: "Charlie" } } }
], ordered: false)

Delete

db.coll.deleteOne({name: "Max"})
db.coll.deleteMany({name: "Max"}, {"writeConcern": {"w": "majority", "wtimeout": 5000}})
db.coll.deleteMany({}) // WARNING! Deletes all documents, but not the collection or its index definitions
db.coll.findOneAndDelete({"name": "Max"})

Databases and Collections

Database Information

db.getName()
db.getSiblingDB("dbname")
db.stats()

Create Collection with Schema Validation

// Create collection with a $jsonschema
db.createCollection("contacts", {
   validator: {$jsonSchema: {
      bsonType: "object",
      required: ["phone"],
      properties: {
         phone: {
            bsonType: "string",
            description: "Required. Must be a string."
         },
         email: {
            bsonType: "string",
            pattern: "@mongodb\.com$",
            description: "String that matches the regular expression."
         },
         status: {
            enum: [ "Unknown", "Incomplete" ],
            description: "Must be one of the preceding enum values."
         }
      }
   }}
})

Import or Export Data

Important

These are MongoDB database tool commands, not mongosh methods. Run them in your system terminal.

// Import JSON data
mongoimport --db mydb --collection mycoll --file data.json
// Export to JSON
mongoexport --db mydb --collection mycoll --out data.json
// Import CSV data
mongoimport --db mydb --collection mycoll --type csv --headerline --file data.csv
// Create database dump
mongodump --db mydb --out backup/
// Restore from dump
mongorestore backup/

Drop

Warning

The following commands delete data permanently. Use them with caution, especially in a production environment.

db.coll.drop()    // removes the collection and its index definitions
db.dropDatabase() // removes the database. USE CAUTION.

Other Collection Functions

db.getCollectionNames()
db.getCollectionInfos()
db.printCollectionStats()
db.coll.stats()            // collection statistics including size, count, and indexes
db.coll.storageSize()      // collection data storage size, in bytes
db.coll.totalIndexSize()   // total size of all collection indexes
db.coll.totalSize()        // total size of collection data and indexes
db.coll.validate({full: true})
db.coll.renameCollection("new_coll", true)   // rename collection. WARNING: "true" drops any existing collection with the same name

Indexes

List Indexes

db.coll.getIndexes()
db.coll.getIndexKeys()

Create Indexes

Index Types

// Index Types
db.coll.createIndex({"name": 1})                // single field index
db.coll.createIndex({"name": 1, "date": 1})     // compound index
db.coll.createIndex({foo: "text", bar: "text"}) // text index
db.coll.createIndex({"$**": "text"})            // wildcard text index
db.coll.createIndex({"userMetadata.$**": 1})    // wildcard index
db.coll.createIndex({"loc": "2d"})              // 2d index
db.coll.createIndex({"loc": "2dsphere"})        // 2dsphere index
db.coll.createIndex({"_id": "hashed"})          // hashed index

Index Options

// Index Options
db.coll.createIndex({"lastModifiedDate": 1}, {expireAfterSeconds: 3600})      // TTL index
db.coll.createIndex({"name": 1}, {unique: true})
db.coll.createIndex({"name": 1}, {partialFilterExpression: {age: {$gt: 18}}}) // partial index
db.coll.createIndex({"name": 1}, {collation: {locale: 'en', strength: 1}})    // case insensitive index with strength 1 or 2
db.coll.createIndex({"name": 1 }, {sparse: true})

Drop Indexes

db.coll.dropIndex("name_1")

Hide or Unhide Indexes

db.coll.hideIndex("name_1")
db.coll.unhideIndex("name_1")

Transactions and Change Streams

Transactions

// Start a session for transactions
session = db.getMongo().startSession()
session.startTransaction()
try {
   // Perform multiple operations
   session.getDatabase("mydb").mycollection.insertOne({name: "Alice"})
   session.getDatabase("mydb").mycollection.updateOne({name: "Bob"}, {$set: {status: "updated"}})
   // Commit the transaction
   session.commitTransaction()
} catch (error) {
  // Abort the transaction on error
  session.abortTransaction()
  throw error
} finally {
  session.endSession()
}

Change Streams

watchCursor = db.coll.watch( [ { $match : {"operationType" : "insert" } } ] )
while (!watchCursor.isExhausted()){
   if (watchCursor.hasNext()){
      print(tojson(watchCursor.next()));
   }
}

Server Management and Replication

Server Commands

db.serverStatus()
db.hostInfo()
db.shutdownServer()
db.fsyncLock()    // flush pending operations and lock the server
db.fsyncUnlock()  // reduce the lock count on the server

Replica Sets

db.getReplicationInfo()
db.printReplicationInfo()
rs.status()
rs.initiate({"_id": "RS1",
   members: [
      { _id: 0, host: "mongodb1.net:27017" },
      { _id: 1, host: "mongodb2.net:27017" },
      { _id: 2, host: "mongodb3.net:27017" }]
rs.add("mongodb4.net:27017")
rs.addArb("mongodb5.net:27017")
rs.remove("mongodb1.net:27017")
rs.conf()
rs.hello()
rs.printReplicationInfo()
rs.printSecondaryReplicationInfo()
rs.reconfig(config)
rs.reconfigForPSASet(memberIndex, config, { options } )
db.getMongo().setReadPref('secondaryPreferred')
rs.stepDown(20, 5) // (stepDownSecs, secondaryCatchUpPeriodSecs)

Sharded Clusters

db.printShardingStatus()
sh.status()
sh.addShard("rs1/mongodb1.example.net:27017")
sh.enableSharding("mydb")
sh.disableSharding("mydb.coll")
sh.shardCollection("mydb.coll", {zipcode: 1})
sh.moveChunk("mydb.coll", { zipcode: "53187" }, "shard0019")
sh.splitChunk("mydb.coll", { "shardKey": value })
sh.splitAt("mydb.coll", {x: 70})
sh.splitFind("mydb.coll", {x: 70})
sh.updateZoneKeyRange("mydb.coll", {state: "NY", zip: MinKey }, { state: "NY", zip: MaxKey }, "NY")
sh.removeRangeFromZone("mydb.coll", {state: "NY", zip: MinKey }, { state: "NY", zip: MaxKey })
sh.addShardToZone("shard0000", "NYC")
sh.removeShardFromZone("shard0000", "NYC")
sh.startAutoMerger()
sh.stopAutoMerger()
sh.enableAutoMerger()
sh.disableAutoMerger()

Documents and Fields

ObjectIds

// ObjectId
ObjectId() // generates a new ObjectId
ObjectId("507f1f77bcf86cd799439011") // creates ObjectId from string
ObjectId().getTimestamp() // returns the timestamp portion
ObjectId().toString() // converts to string representation
ObjectId().valueOf() // returns the string value

Data Types and Type Checking

// BSON data types
NumberInt(42)           // 32-bit integer
NumberLong(42)          // 64-bit integer
NumberDecimal("42.42")  // 128-bit decimal
// Date operations
new Date()              // current date/time
ISODate()               // current date/time in ISO format
ISODate("2023-01-01")   // specific date
// Binary data
BinData(0, "base64encodedstring")
// Regular expressions
/<pattern>/<flags>
// Check data types
typeof value
db.coll.find({field: {$type: "string"}})

Performance and Optimization

// Query performance analysis
db.coll.find({name: "John"}).explain()
db.coll.find({name: "John"}).explain("executionStats")
// Collection statistics
db.coll.stats()
db.coll.totalIndexSize()
db.coll.storageSize()
// Database profiling and logging
db.setProfilingLevel(2)  // Profile all operations
db.setProfilingLevel(1, 100)  // Profile slow operations (>100ms)
db.setProfilingLevel(0)  // Turn off profiling
db.getProfilingStatus()
// View profile data
db.system.profile.find().sort({ts: -1}).limit(5)
// Current operations
db.currentOp()
db.killOp(operationId)
// Server and database stats
db.serverStatus()
db.stats()

Back

Create Registry Index File

Compatibility Changes