MongoDB Shell Cheat Sheet

To get started, install the MongoDB Shell (mongosh).

Basic Commands
These basic help commands are available in the MongoDB Shell.

mongosh Open a connection to your local

MongoDB instance. All other
commands will be run within this
mongosh connection.

db.help() Show help for database methods.

db.<collection>.help() Show help on collection methods. The

<collection> can be the name of an
existing collection or a non-existing
collection.
db.users.help() Shows help on methods related to the users
collection.

show dbs Print a list of all databases on the

server.

use <db> Switch current database to <db>. The

mongo shell variable db is set to the
current database.

show collections Print a list of all collections for the

current database.

show users Print a list of users for the current

database.

show roles Print a list of all roles, both

user-defined and built-in, for the
current database.

show profile Print the five most recent operations

that took 1 millisecond or more on
databases with profiling enabled.
show databases Print a list of all existing databases
available to the current user.

exit Exit the mongosh session.

Create Operations
Create or insert operations add new documents to a collection. If the collection
does not exist, create operations also create the collection.

db.collection.insertOne() Inserts a single document into a

collection.
db.users.insertOne( { name: "Chris"} Add a new document with the name of Chris
) into the users collection

db.collection.insertMany() Inserts multiple documents into a

collection.
db.users.insertMany( { age: "24"}, Add two new documents with the age of 24
{age: "38"} ) and 38 into the users collection

Read Operations
Read operations retrieve documents from a collection; i.e. query a collection for
documents.

db.collection.find() Selects documents in a collection or

view and returns a cursor to the
selected documents.
db.users.find() Returns all users.

db.collection.find(<filterobjec Find all documents that match the

t>) filter object
db.users.find({place: "NYC"}) Returns all users with the place NYC.

db.collection.find({<field>:1,< Returns all documents that match the

field>:1}) query after you explicitly include
several fields by setting the <field> to 1
in the projection document.
db.users.find({status:1,item:1}) Returns matching documents only from state
field, item field and, by default, the _id field.
db.collection.find({<field>:1,< Returns all documents that match the
field>:0, _id:0}) query and removes the _id field from
the results by setting it to 0 in the
projection.
db.users.find({status:1,item:1,_id:0} Returns matching documents only from state
) field and item field. Does not return the _id
field.

Update Operations
Update operations modify existing documents in a collection.

db.collection.updateOne() Updates a single document within the

collection based on the filter.
db.users.updateOne({ age: 25 }, Updates all users from the age of 25 to 32.
{ $set: { age: 32 } })

db.collection.updateMany() Updates a single document within the

collection based on the filter.
db.users.updateMany({ age: 27 }, Updates all users with an age of 27 with an
{ $inc: { age: 3 } }) increase of 3.

db.collection.replaceOne() Replaces a single document within the

collection based on the filter.
db.users.replaceOne({ name: Kris }, { Replaces the first user with the name Kris with
name: Chris }) a document that has the name Chris in its
name field.

Delete Operations
Delete operations remove documents from a collection.

db.collection.deleteOne() Removes a single document from a

collection.
db.users.deleteOne({ age: 37 }) Deletes the first user with the age 37.

db.collection.deleteMany() Removes all documents that match the

filter from a collection.
db.users.deleteMany({ age: {$lt:18 }) Deletes all users with the age less than 18..
Comparison Query Operators
Use the following inside an filter object to make complex queries

$eq Matches values that are equal to a

specified value.
db.users.find({ system: { $eq: Finds all users with the operating system
"macOS" } }) macOS.

$gt Matches values that are greater than a

specified value.
db.users.deleteMany({ age: { $gt: 99} Deletes all users with an age greater than 99.
})

$gte Matches values that are greater than

or equal to a specified value.
db.users.updateMany({ age": {$gte:21 Updates all access to "valid" for all users with
},{access: "valid"}) an age greater than or equal to 21.

$in Matches any of the values specified in

an array.
db.users.find( { place: { $in: [ Find all users with the place field that is either
"NYC", "SF"] } ) NYC or SF.

$lt Matches values that are less than a

specified value.
db.users.deleteMany({ "age": {$lt:18 Deletes all users with the age less than 18..
})

$lte Matches values that are less than or

equal to a specified value.
db.users.updateMany({ age: { $lte: 17 Updates all access to "invalid" for all users
}, {access: "invalid"}) with an age less than or equal to 17.

$ne Matches all values that are not equal

to a specified value.
db.users.find({ "place": {$ne: Find all users with the place field set to
‘NYC"}) anything other than NYC.
$nin Matches none of the values specified
in an array.
db.users.find( { place: { $nin: [ Find all users with the place field that does not
"NYC", "SF" ] } ) equal NYC or SF.

Field Update Operators

Use the following inside an update object to make complex updates

$inc Increments the value of the field by

db.users.updateOne({ age: 22 }, { the specified amount.
$inc: { age: 3} }) Adds 3 to the age of the first user with the age
of 22.

$min Only updates the field if the specified

value is less than the existing field
db.scores.insertOne( { _id: 1, value.
highScore: 800, lowScore: 200 } ) Creates a scoles collection and sets the value
of highScore to 800 and lowScore to 200.

db.scores.updateOne( { _id: 1 }, { $min compares 200 (the current value of

$min: { lowScore: 150 } } ) lowScore) to the specified value of 150.
Because 150 is less than 200, $min will update
lowScore to 150.

$max Only updates the field if the specified

value is greater than the existing field
value.
db.scores.updateOne( { _id: 1 }, { $max compares 800 (the current value of
$max: { highScore: 1000 } } ) highScore) to the specified value of 1000.
Because 1000 is more than 800, $max will
update highScore to 1000.

$rename Renames a field.

db.scores.updateOne( { $rename: { Renames the field ‘highScores’ to ‘high’,
'highScore': 'high'} )
$set Sets the value of a field in a
document.
db.users.updateOne({ $set: { name: Replaces the value of the name field with the
"valid user" } }) specified value valid user.

$unset Removes the specified field from a

db.users.updateOne({ $unset: { name: document.
"" } }) Deletes the specified value valid user from the
name field.

Read Modifiers
Add any of the following to the end of any read operation

cursor.sort() Orders the elements of an array

during a $push operation.
db.users.find().sort({ name: 1, age: Sorts all users by name in alphabetical order
-1 }) and then if any names are the same sort by
age in reverse order

cursor.limit() Specifies the maximum number of

documents the cursor will return.

cursor.skip() Controls where MongoDB begins

returning results.

cursor.push() Appends a specified value to an array.

db.users.updateMany({}, { $push: { Add Chris to the friends array for all users
friends: "Chris" } })
Aggregation Operations
The Aggregation Framework provides a specific language that can be used to
execute a set of aggregation operations (processing & computation) against
data held in MongoDB.

db.collection.aggregate() A method that provides access to the

aggregation pipeline.

db.users.aggregate([ Selects documents in the users collection with

{$match: { access: "valid" } }, accdb.orders.estimatedDocumentCount({})_id
{$group: { _id: "$cust_id", field from the sum of the amount field, and
total:{$sum: "$amount" } } }, sorts the results by the total field in descending
{$sort: { total: -1 } }]) order:

Aggregation Operations
Aggregation pipelines consist of one or more stages that process documents
and can return results for groups of documents.

count Counts the number of documents in a

collection or a view.

distinct Displays the distinct values found for a

specified key in a collection or a view.

mapReduce Run map-reduce aggregation

operations over a collection

Aggregation Operations
Single Purpose Aggregation Methods aggregate documents from a single
collection.

db.collection.estimatedDocument Returns an approximate count of the

Count() documents in a collection or a view.
db.users.estimatedDocumentCount({}) Retrieves an approximate count of all the
documents in the users collection.
db.collection.count() Returns a count of the number of
documents in a collection or a view.
db.users.count({}) Returns the distinct values for the age field
from all documents in the users collection.

db.collection.distinct() Returns an array of documents that

have distinct values for the specified
field.
db.users.distinct("age") Returns the distinct values for the age field
from all documents in the users collection.

Indexing Commands
Indexes support the efficient execution of queries in MongoDB. Indexes are
special data structures that store a small portion of the data set in an
easy-to-traverse form.

db.collection.createIndex() Builds an index on a collection.

db.users.createIndex("account Creates the account creation date index in the
creation date") users collection.

db.collection.dropIndex() Removes a specified index on a

collection.
db.users.dropIndex("account creation Removes the account creation date index from
date") the users collection.

db.collection.dropIndexes() Removes all indexes but the _id (no

parameters) or a specified set of
indexes on a collection.
db.users.dropIndexes() Drop all but the _id index from a collection.

db.users.dropIndex("account creation
Removes the account creation date index and
date", "account termination date")
the account termination date index from the
users collection.
db.collection.getIndexes() Returns an array of documents that
describe the existing indexes on a
collection.
db.users.getIndexes() Returns an array of documents that hold index
information for the users collection.

db.collection.reIndex() Rebuilds all existing indexes on a

collection
db.users.reIndex() Drops all indexes on the users collection and
recreates them.

db.collection.totalIndexSize() Reports the total size used by the

indexes on a collection. Provides a
wrapper around the totalIndexSize
field of the collStats output.
db.users.totalIndexSize() Returns the total size of all indexes for the
users collection.

Replication Commands
Replication refers to the process of ensuring that the same data is available on
more than one MongoDB Server.

rs.add() Adds a member to a replica set.

rs.add( "mongodbd4.example.net:27017" Adds a new secondary member,
) mongodbd4.example.net:27017, with default
vote and priority settings to a new replica set

rs.conf() Returns a document that contains the

current replica set configuration.

rs.status() Returns the replica set status from the

point of view of the member where the
method is run.
rs.stepDown() Instructs the primary of the replica set
to become a secondary. After the
primary steps down, eligible
secondaries will hold an election for
primary.

rs.remove() Removes the member described by the

hostname parameter from the current
replica set.

rs.reconfig() Reconfigures an existing replica set,

overwriting the existing replica set
configuration.

Sharding Commands
Sharding is a method for distributing or partitioning data across multiple
computers. This is done by partitioning the data by key ranges and distributing
the data among two or more database instances.

sh.abortReshardCollection() Ends a resharding operation

sh.abortReshardCollection("users") Aborts a running reshard operation on the
users collection.

sh.addShard() Adds a shard to a sharded cluster.

sh.addShard("cluster"/mongodb3.exampl Adds the cluster replica set and specifies one
e.net:27327") member of the replica set.

sh.commitReshardCollection Forces a resharding operation to block

() writes and complete.
sh.commitReshardCollection("records.u Forces the resharding operation on the
sers") records.users to block writes and complete.
sh.disableBalancing() Disable balancing on a single
collection in a sharded database. Does
not affect balancing of other
collections in a sharded cluster.
sh.disableBalancing("records.users") Disables the balancer for the specified
sharded collection.

sh.enableAutoSplit() Enables auto-splitting for the sharded

cluster.

sh.disableAutoSplit() Disables auto-splitting for the sharded

cluster.

sh.enableSharding() Creates a database.

sh.enablingSharding("records") Creates the records database.

sh.help() Returns help text for the sh methods.

sh.moveChunk() Migrates a chunk in a sharded cluster.

sh.moveChunk("records.users", { Finds the chunk that contains the documents
zipcode: "10003" }, "shardexample") with the zipcode field set to 10003 and then
moves that chunk to the shard named
shardexample.

sh.reshardCollection() Initiates a resharding operation to

change the shard key for a collection,
changing the distribution of your data.
sh.reshardCollection("records.users", Reshards the users collection with the new
{ order_id: 1 }) shard key { order_id: 1 }

sh.shardCollection() Enables sharding for a collection.

sh.shardCollection("records.users", Shards the users collection by the zipcode
{ zipcode: 1 } ) field.
sh.splitAt() Divides an existing chunk into two
chunks using a specific value of the
shard key as the dividing point.
sh.splitAt( "records.users", { x: 70 Splits a chunk of the records.users collection at
} ) the shard key value x: 70

sh.splitFind() Divides an existing chunk that contains

a document matching a query into two
approximately equal chunks.
sh.splitFind( "records.users", { x:70 Splits, at the median point, a chunk that
} ) contains the shard key value x: 70.

sh.status() Reports on the status of a sharded

cluster, as db.printShardingStatus().

sh.waitForPingChange() Internal. Waits for a change in ping

state from one of the mongos in the
sharded cluster.

refineCollectionShardKey Modifies the collection's shard key by

adding new field(s) as a suffix to the
existing key.
db.adminCommand( { shardCollection: Shard the orders collection in the test
"test.orders", key: { customer_id: 1 database. The operation uses the customer_id
} } ) field as the initial shard key.

db.getSiblingDB("test").orders.create Create the index to support the new shard key

Index( { customer_id: 1, order_id: 1 if the index does not already exist.
} )

db.adminCommand( { Run refineCollectionShardKey command to

refineCollectionShardKey: add the order_id field as a suffix
"test.orders",
key: { customer_id: 1, order_id: 1
}
} )
convertShardKeyToHashed() Returns the hashed value for the input.

use test Consider a sharded collection that uses a

db.orders.createIndex( { _id: hashed shard key.
"hashed" } )
sh.shardCollection( "test.orders", {
_id : "hashed" } )

{ If the following document exists in the

_id: collection, the hashed value of the _id field is
ObjectId("5b2be413c06d924ab26ff9ca"), used to distribute the document:
"item" : "Chocolates",
"qty" : 25
}

convertShardKeyToHashed( Determine the hashed value of _id field used

ObjectId("5b2be413c06d924ab26ff9ca") to distribute the document across the shards,
)

Database Methods

db.runCommand() Run a command against the current

database

db.adminCommand() Provides a helper to run specified

database commands against the
admin database.
User Management Commands
Make updates to users in the MongoDB Shell.

db.auth() Authenticates a user to a database.

db.changeUserPassword() Updates a user's password.

db.createUser() Creates a new user for the database

on which the method is run.

db.dropUser() Removes user/all users from the

db.dropAllUsers() current database.

db.getUser() Returns information for a specified

db.getUsers() user/all users in the database.

db.grantRolesToUser() Grants a role and its privileges to a

user.

db.removeUser() Removes the specified username from

the database.

db.revokeRolesFromUser() Removes one or more roles from a user

on the current database.

db.updateUser() Updates the user's profile on the

database on which you run the
method.

passwordPrompt() Prompts for the password in mongosh.

 Role Management Commands
Make updates to roles in the MongoDB Shell.

db.createRole() Authenticates a user to a database.

db.dropRole() Deletes a user-defined role/all

db.dropAllRoles() user-defined roles associated with a
database.

db.getRole() Returns information for the specified

db.getRoles() role/all the user-defined roles in a
database.

db.grantPrivilegesToRole() Assigns privileges to a user-defined

role.

db.revokePrivilegesFromRole() Removes the specified privileges from

a user-defined role.

db.grantRolesToRole() Specifies roles from which a

user-defined role inherits privileges.

db.revokeRolesFromRole() Removes inherited roles from a role.

db.updateRole() Updates a user-defined role.

ff