MongoDB Cheat SheetMongoDB备忘单

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() )

Show Databases

show dbs
db // prints the current database

Switch Database

use <database_name>

Show Collections

show collections

Run JavaScript File

load("myScript.js")

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

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
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
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
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
db.coll.find({name: {$exists: true}})
db.coll.find({"zipCode": {$type: 2 }})
db.coll.find({"zipCode": {$type: "string"}})

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

// 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"}})

// 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]
            ]]
         }
      }
   }
})

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

// 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
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
db.coll.find({}).sort({"year": 1, "rating": -1}).skip(10).limit(3)

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

Update

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
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
db.coll.findOneAndUpdate({"name": "Max"}, {$inc: {"points": 5}}, {returnNewDocument: true})

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

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

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

// 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"})

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

// 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

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

List Indexes

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

Create Indexes

// 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
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

// 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 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()

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"}})