MongoDB Shell Guide – Operations and Commands

show databases

• use local
• show collections

Note: Only a fragment of the output is shown.

result = db.getSiblingDB( 'admin' )
.runCommand( { listDatabases: 1 } );
for( index in result.databases ) {
    print( result.databases[ index ].name );
}

In MongoDB shell, let us issue the command: load( ‘db.js’ )

hostname()

http://docs.mongodb.org/manual/reference/method/getHostName/

• resident: the subset of a memory currently stored in physical RAM
• virtual: a working memory, typically residing on both disk and in physical RAM

Note: Only a fragment of the output is shown.

http://docs.mongodb.org/manual/reference/method/db.listCommands/

{ 
    fromhost: <hostname>,
    fromdb: <database>,
    todb: <database>,
    slaveOk: <true|false>,
    username: <username>,
    nonce: <nonce>,
    key: <key> 
}

db.getSiblingDB('admin').runCommand( { 
    copydb: 1, 
    fromdb: 'test', 
    todb: 'test2' 
} )

Alternatively, let us run the same command using MongoDB shell wrapper: db.copyDatabase( ‘test’, ‘test2’ )

The consecutive run of show dbs outputs the new database test2 in the list after each command run.

http://docs.mongodb.org/manual/reference/method/db.copyDatabase/

• use test2
• db.dropDatabase()

Alternatively, let us run the same command using runCommand() call:

• use test2
• db.runCommand( { dropDatabase: 1 } )

Or even shortest version: db.getSiblingDB( ‘test2’ ).dropDatabase()

http://docs.mongodb.org/manual/reference/method/db.dropDatabase/

Alternatively, let us run the same command using runCommand() call: db.runCommand( { clone: ‘localhost:27018’ } )

http://docs.mongodb.org/manual/reference/method/db.cloneDatabase/

{ 
    preserveClonedFilesOnFailure: <true|false>,
    backupOriginalFiles: <true|false> 
}

Alternatively, let us run the same command using runCommand() call: db.runCommand( { repairDatabase: 1 } )

http://docs.mongodb.org/manual/reference/method/db.repairDatabase/

{ 
    async: <true|false>, 
    lock: <true|false> 
}

• db.fsyncLock ()
• db.fsyncUnlock()

Alternatively, let us run the same command using runCommand() call:

• db.adminCommand( { fsync: 1, lock: true } )
• db.fsyncUnlock()

http://docs.mongodb.org/manual/reference/method/db.fsyncLock/

http://docs.mongodb.org/manual/reference/method/db.fsyncUnlock/

{ 
    scale: <scale>
}

Alternatively, let us run the same command using runCommand() call: db.runCommand( { dbStats: 1 } )

http://docs.mongodb.org/manual/reference/method/db.stats/

Note: Only a fragment of the output is shown.

{ 
    create: <collection>,
    capped: <true|false>,
    autoIndexId: <true|false>,
    size: <max_size>,
    max: <max_documents>,
    flags: <0|1>
}

Alternatively, let us run the same command using runCommand() call: db.runCommand( { create: ‘mycoll’, capped: false } )

The consecutive call to db.getCollectionNames() outputs the newly created collections.

http://docs.mongodb.org/manual/reference/method/db.createCollection/

{ 
    drop: <collection> 
}

• db.createCollection( ‘mycoll’ )
• db.mycoll.drop()

Alternatively, let us run the same command using runCommand() call: db.runCommand( { drop: ‘mycoll’ } )

http://docs.mongodb.org/manual/reference/method/db.collection.drop/

{ 
    renameCollection: <source_namespace>, 
    to: <target_namespace>, 
    dropTarget: <true|false> 
}

• db.createCollection( ‘mycoll’ )
• db.mycoll.renameCollection( ‘mycoll2’ )

Alternatively, let us run the same command using runCommand() call: db.adminCommand( { renameCollection: ‘test.mycoll’, to: ‘test.mycoll2’ } )

http://docs.mongodb.org/manual/reference/method/db.collection.renameCollection/

{
    validate: <collection>,
    full: <true|false>
}

• db.createCollection( ‘mycoll’ )
• db.mycoll.validate()

Alternatively, let us run the same command using runCommand() call: db.runCommand( { validate: ‘mycoll’ } )

http://docs.mongodb.org/manual/reference/method/db.collection.validate/

{ 
    cloneCollection: <namespace>, 
    from: <hostname>, 
    query: { <query> } 
}

Alternatively, let us run the same command using runCommand() call: db.runCommand( { cloneCollection: ‘test.mycoll’, from: ‘localhost:27018’ } )

http://docs.mongodb.org/manual/reference/method/db.cloneCollection/

{ 
    cloneCollectionAsCapped: <existing collection>, 
    toCollection: <capped collection>, 
    size: <capped size> 
}

db.createCollection( 'mycoll' )

db.runCommand( { 
    cloneCollectionAsCapped: 'mycoll', 
    toCollection: 'mycollcapped', 
    size: 10 
} )

{
    convertToCapped: <collection>, 
    size: <capped size> 
}

db.createCollection( 'mycoll' )

db.runCommand( { 
    convertToCapped: 'mycoll', 
    size: 10 
} )

{ 
    collStats: <collection>, 
    scale : <scale> 
}

db.<collection>.stats(<scale>)
db. <collection>.totalSize()
db. <collection>.dataSize()
db. <collection>.totalIndexSize()
db. <collection>.storageSize()

Alternatively, let us run the same command using runCommand() call: db.runCommand( { collStats: ‘mycoll’ } )

http://docs.mongodb.org/manual/reference/method/db.collection.stats/

http://docs.mongodb.org/manual/reference/method/db.collection.totalSize/

http://docs.mongodb.org/manual/reference/method/db.collection.dataSize/

http://docs.mongodb.org/manual/reference/method/db.collection.totalIndexSize/

http://docs.mongodb.org/manual/reference/method/db.collection.storageSize/

http://docs.mongodb.org/manual/reference/method/db.printCollectionStats/

{
    createIndexes: <collection>,
    indexes: [
        {
            key: {
                <key-value_pair>,
                <key-value_pair>,
                ...
            },
            name: <index_name>,
            <option1>,
            <option2>,
            ...
        },
        { ... },
        { ... }
    ]
}

Alternatively, let us run the same command using runCommand() call:

db.runCommand( { 
    createIndexes: 'mycoll',
    indexes: [
        {
            key: { content: 'text' },
            name: 'myindex'
        }
    ]
} )

http://docs.mongodb.org/manual/reference/method/db.collection.ensureIndex/

{ 
    dropIndexes: <collection>, 
    index: <index> 
}

db.<collection>.dropIndex(<index>)

db.mycoll.ensureIndex( { content: "text" } )

db.mycoll.dropIndexes()

Alternatively, let us run the same command using runCommand() call: db.runCommand( { dropIndexes: ‘mycoll’, index: ‘*’ } )

http://docs.mongodb.org/manual/reference/method/db.collection.dropIndexes/

http://docs.mongodb.org/manual/reference/method/db.collection.dropIndex/

{ 
    reIndex: <collection>
}

Alternatively, let us run the same command using runCommand() call: db.runCommand( { reIndex: ‘mycoll’ } )

http://docs.mongodb.org/manual/reference/method/db.collection.reIndex/

{ 
    compact: <collection>
}

{
    collMod: <collection> , 
    <flag> : <value> 
}

db.createCollection( 'mycoll' )

db.mycoll.copyTo( 'mycollcopy' )

{
  insert: <collection>,
  documents: [ <document>, <document>, <document>, ... ],
  ordered: <true|false>,
  writeConcern: { <write concern> }
}

db.<collection>.save(<document>, writeConcern: { … })

db.books.insert( {
  "title": "MongoDB In Action",
  "author": { "firstName": "Kyle", "lastName": "Banker" },
  "isbn": "978-1935182870",
  "published": new Date("Dec 16, 2011" ),
  "categories": [ "NoSQL", "Document Databases" ]
} )

Alternatively, let us run the same command using runCommand() call:

db.runCommand( { 
  insert: 'books',
  documents: [
      {
        "title": "MongoDB In Action",
        "author": { "firstName": "Kyle", "lastName": "Banker" },
        "isbn": "978-1935182870",
        "published": new Date("Dec 16, 2011" ),
        "categories": [ "NoSQL", "Document Databases" ]
      }
  ]
} )

Considering an example with reference from Book to its Author, let us issue the following commands in MongoDB shell:

db.authors.insert( {
    "_id": "kyle-banker", 
    "firstName": "Kyle", 
    "lastName": "Banker"
} )

db.books.insert( {
    "title": "MongoDB In Action",
    "author": { "$ref": "authors", "$id": "kyle-banker" },
    "isbn": "978-1935182870",
    "published": new Date("Dec 16, 2011" ),
    "categories": [ "NoSQL", "Document Databases" ]
} )

http://docs.mongodb.org/manual/reference/method/db.collection.insert/

http://docs.mongodb.org/manual/reference/method/db.collection.save/

{
  update: <collection>,
  updates: [
    { q: <query>, u: <update>, upsert: <true|false>, 
multi: <true|false> },
    { q: <query>, u: <update>, upsert: <true|false>, 
multi: <true|false> },
    { q: <query>, u: <update>, upsert: <true|false>, 
multi: <true|false> },
    ...
  ],
  ordered: <true|false>,
  writeConcern: { <write concern> }
}

db.<collection>.save(<document>, writeConcern: { … })

By default, the command updates a single document unless the parameter multi is to true andthen an update of all documents that match the query criteria will be performed.

The query syntax will be discussed in details in Queries section.

db.books.update(
    { "title": "MongoDB In Action" }, 
    {
        "rating": 5,
        "categories": [ "NoSQL", "Document Databases",  "MongoDB" ]
    },
    { upsert: true }
)

Because we have executed the upsert, the result of the execution hints us that no matches have been found and a new document has been inserted.

Alternatively, let us run the same command using runCommand() call:

db.runCommand( {
  "update": "books", 
  "updates": [ 
    {
      "q": { "title": "MongoDB In Action" }, 
      "u": {
        "rating": 5,
        "categories": [ "NoSQL", "Document Databases",  "MongoDB" ]
      },
      upsert: true
    }
  ]
} )

http://docs.mongodb.org/manual/reference/method/db.collection.update/

http://docs.mongodb.org/manual/reference/method/db.collection.save/

{
    delete: <collection>,
    deletes: [
         { q : <query>, limit : <integer> },
         { q : <query>, limit : <integer> },
         { q : <query>, limit : <integer> },
         ...
   ],
   ordered: <true|false>,
   writeConcern: { <write concern> }
}

The query syntax will be discussed in details in Queries section.

db.books.remove(
    { "title": "MongoDB In Action" }, 
    { "justOne": true }
)

Alternatively, let us run the same command using runCommand() call:

db.runCommand( {
    "delete": "books", 
    "deletes": [ 
        {
            "q": { "title": "MongoDB In Action" }, 
            "limit": 1
        }
    ]
} )

http://docs.mongodb.org/manual/reference/method/db.collection.remove/

{
    findAndModify: <collection>,
    query: <query>,
    sort: <sort>,
    remove: <true|false>,
    update: <update>,
    new: <true|false>,
    fields: <fields>,
    upsert: <true|false>,
}

db.books.insert( {
    "title": "MongoDB In Action",
    "author": { firstName: "Kyle", lastName: "Banker" },
    "isbn": "978-1935182870",
    "published": new Date("Dec 16, 2011" ),
    "categories": [ "NoSQL", "Document Databases" ]
} )

db.books.findAndModify( {
    "query": { "title": "MongoDB In Action" }, 
    "remove": false,
    "new": true,
    "update": {
        "rating": 5,
        "categories": [ "NoSQL", "Document Databases",  "MongoDB" ]
    }
} )

Alternatively, let us run the same command using runCommand() call:

db.runCommand( {
    "findAndModify": "books", 
    "query": { "title": "MongoDB In Action" },
    "update": {
        "rating": 5,
        "categories": [ "NoSQL", "Document Databases",  "MongoDB" ]
    },
    "remove": false,
    "new": true
} )

http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/

MongoDB supports a rich set of query operators (for more details please refer to official documentation):

• $gt
• $gte
• $in
• $lt
• $lte
• $ne
• $nin
• $or
• $and
• $not
• $nor
• $exists
• $type
• $mod
• $regex
• $text
• $where
• $geoWithin
• $geoIntersects
• $near
• $nearSphere
• $all
• $elemMatch
• $size
• $elemMatch
• $meta
• $slice

The <projection> parameter specifies which fields of the document should be selected and returned to the clients:

{ 
    field1: <true|false>, 
    field2: <true|false> 
    ...
}

• db.books.insert( { “title”: “MongoDB In Action” } )
• db.books.insert( { “title”: “MongoDB. The Definitive Guide” } )
• db.books.find( { “title”: { “$regex”: “MongoDB*” } } )

• db.books.insert( { “title”: “MongoDB In Action”, “price”: 10 } )
• db.books.insert( { “title”: “MongoDB. The Definitive Guide”, “price”: 15 } )
• db.books.findOne( { “price”: { “$gt”: 10 } }, { “title”: 1, “_id”: 0 } )

{
    geoNear: <collection>,
    near: <point>,
    limit: <limit>,
    num: <num>,
    maxDistance: <distance>,
    query: <query>,
    spherical: <true|false>,
    distanceMultiplier: <multiplier>,
    includeLocs: <true|false>,
    uniqueDocs: <true|false>
}

db.stores.insert( { "name": "BestBuy", "location": [ 10, 15 ] } )

db.stores.ensureIndex( { "location": "2d" } )

db.runCommand( { 
    "geoNear": "stores",
    "near": [ 10, 14 ],
    "maxDistance": 6
} ) 	

{ 
    geoSearch : <collection>,
    near: <point>, 
    maxDistance: <distance>,
    search: <query>, 
    limit: <limit> 
}

db.stores.insert( { "name": "BestBuy", "location": [ 10, 15 ] } )

db.stores.ensureIndex( 
    { "location": "geoHaystack", "name": 1 }, 
    { "bucketSize": 1 } 
)

db.runCommand( { 
    "geoSearch": "stores",
    "near": [ 10, 14 ],
    "maxDistance": 6,
    "search": { "name": "BestBuy" }
} ) 

{ 
    count: <collection>, 
    query: <query>, 
    limit: <limit>, 
    skip: <skip>, 
    hint: <hint> 
}

Alternatively, let us run the same command using runCommand() call: db.runCommand( {

“count”: “mycoll” } )

http://docs.mongodb.org/manual/reference/method/db.collection.count/

{ 
    distinct: <collection>, 
    key: <field>, 
    query: <query> 
}

db.books.insert( { "title": "MongoDB In Action" } )

db.books.insert( { "title": "MongoDB. The Definitive Guide" } )

db.books.distinct("title" )

Alternatively, let us run the same command using runCommand() call: db.runCommand( {

“distinct“: “books”, “key“: “title” } )

http://docs.mongodb.org/manual/reference/method/db.collection.distinct/

{
    group:
    {
         ns: <namespace>,
         key: <key>,
         $reduce: <reduce function>,
         Initial: <initial>,   
         $keyf: <key function>,
         cond: <query>,
         finalize: <finalize function>
   }
}

db.books.insert( { "title": "MongoDB In Action" } )

db.books.insert( { "title": "MongoDB. The Definitive Guide" } )

db.books.group( 
{ 
    "key": "title", 
    "reduce": function ( curr, result ) { result.total += 1 }, 
    "initial": { "total": 0 } 
} )

Alternatively, let us run the same command using runCommand() call:

db.runCommand( { 
    "group": { 
        "ns": "books", 
        "key": "title", 
        "$reduce": function ( curr, result ) { result.total += 1 }, 
        "initial": { "total": 0 } 
    } 
} )

http://docs.mongodb.org/manual/reference/method/db.collection.group/

{
    aggregate: <collection>,
    pipeline: [ <stage>, <...> ],
    explain: <true|false>,
    allowDiskUse: <true|false>,
    cursor: <cursor>
}

The pipeline aggregation operators include:

• $project
• $match
• $redact
• $limit
• $skip
• $unwind
• $group
• $sort
• $geoNear
• $out

Each pipeline operator also supports the expression operators to calculate values within the pipeline (for more details please refer to official documentation).

db.books.insert( { "title": "MongoDB In Action", "price": 10 } )

db.books.insert( { "title": "MongoDB. The Definitive Guide", 
"price": 15 } )

db.books.aggregate( [  
{ "$match": { "title":  { "$regex": "MongoDB*" } } },  
{ "$group": { "_id": "mongodb", "total": { "$sum": "$price" } } },  
{ "$sort": { "total": -1 } } 
])

Alternatively, let us run the same command using runCommand() call:

db.runCommand( { 
"aggregate":  "books",     
"pipeline": [
  { "$match": { "title":  { "$regex": "MongoDB*" } } },  
  { "$group": { "_id": "mongodb", "total": { "$sum": "$price" } } },
  { "$sort": { "total": -1 } } 
] 
})

http://docs.mongodb.org/manual/reference/method/db.collection.aggregate/

{ 
    filemd5: <object id>, 
    root: <root> 
}

In MongoDB shell, let us issue the command:

db.runCommand( { 
    "filemd5": ObjectId('536bbb3ffa052c2b649d2ee3'), 
    "root": "fs" 
} )

{
    eval: <function>,
    args: [ <arg1>, <arg2> ... ],
    nolock: <true|false>
}

db.eval( 
    function(title) {
        return db.books.insert( { "title": title } ).nInserted == 1;
    }, 
    "MongoDB in Action" 
)

Alternatively, let us run the same command using runCommand() call:

db.runCommand( {
   "eval":  function(title) {
        return db.books.insert( { "title": title } ).nInserted == 1;
    }, 
    "args": [ "MongoDB in Action" ]
} )

http://docs.mongodb.org/manual/reference/method/db.eval/

Alternatively, let us run the same command using runCommand() call: db.runCommand( { buildInfo: 1 } )

Note: Only a fragment of the output is shown.

http://docs.mongodb.org/manual/reference/method/db.serverBuildInfo/

Alternatively, let us run the same command using runCommand() call: db.runCommand( { hostInfo: 1 } )

Note: Only a fragment of the output is shown.

http://docs.mongodb.org/manual/reference/method/db.hostInfo/

Alternatively, let us run the same command using runCommand() call: db.runCommand( { serverStatus: 1 } )

Note: Only a fragment of the output is shown.

http://docs.mongodb.org/manual/reference/method/db.serverStatus/

use admin

db.shutdownServer()

Alternatively, let us run the same command using runCommand() call: db.adminCommand( { shutdown: 1 } )

Please notice that you have to restart your MongoDB server instance when command finishes execution as it will be terminated and MongoDB shell will not be able to connect to it anymore.

http://docs.mongodb.org/manual/reference/method/db.shutdownServer/

• total
• readLock
• writeLock
• queries
• getmore
• insert
• update
• remove
• commands

It should be run in context of admin database.

Note: Only a fragment of the output is shown.

{ 
    getLog: <log> 
}

• global: the combined output of all recent log entries
• startupWarnings: outputs errors or warnings occurred during the server start
• rs: outputs log entries related to replica set activity

It should be run in context of admin database.

Note: Only a fragment of the output is shown.

{ 
    touch: <collection>, 
    data: <true|false>, 
    index: <true|false> 
}

db.createCollection( "mycoll" )

db.runCommand( { touch: "mycoll", index: true } )

{ 
    <option>: <value> 
}

• journalCommitInterval
• logLevel
• logUserIds
• notablescan
• quiet
• replApplyBatchSize
• replIndexPrefetch
• syncdelay
• traceExceptions
• textSearchEnabled
• sslMode
• clusterAuthMode
• userCacheInvalidationIntervalSecs

It should be run in context of admin database.

{ 
    <option>: <value> 
}