Administration

db.stats()                          // dataSize, storageSize, indexSize, collections
db.orders.stats()                   // per collection, plus per-index sizes
db.orders.countDocuments()
db.orders.totalIndexSize()
db.serverStatus()                   // huge. Pick fields
db.serverStatus().connections       // { current, available, totalCreated }
db.serverStatus().opcounters        // insert, query, update, delete, command
db.serverStatus().wiredTiger.cache  // "bytes currently in the cache" vs "maximum"
db.hostInfo()
db.version()

// Long-running operations, and how to stop one
db.currentOp({ "secs_running": { $gte: 5 }, "op": { $ne: "none" } })
db.currentOp({ waitingForLock: true })
db.killOp(4815162342)               // opid from currentOp

db.aggregate([{ $currentOp: { allUsers: true } },
              { $match: { secs_running: { $gte: 5 } } }])
db.orders.aggregate([{ $collStats: { storageStats: {} } }])

db.setProfilingLevel(1, { slowms: 100 })       // log ops over 100ms
db.setProfilingLevel(1, { sampleRate: 0.1 })   // sample 10% of slow ops
db.getProfilingStatus()
db.setProfilingLevel(0)                        // off

// Slowest recent operations
db.system.profile.find({ millis: { $gt: 200 } })
  .sort({ ts: -1 }).limit(10)
  .forEach(o => print(o.millis, o.op, o.ns, JSON.stringify(o.command).slice(0, 120)))

// Anything that scanned far more than it returned
db.system.profile.find({ $expr: { $gt: ["$docsExamined",
                                        { $multiply: ["$nreturned", 100] }] } })

// Which collections dominate
db.system.profile.aggregate([
  { $group: { _id: "$ns", n: { $sum: 1 }, avg_ms: { $avg: "$millis" } } },
  { $sort: { avg_ms: -1 } }
])

# Whole deployment to one compressed archive
mongodump --uri="$URI" --archive=shop.gz --gzip

# Selective, and point-in-time consistent on a replica set
mongodump --uri="$URI" --archive=shop.gz --gzip --oplog \
  --nsInclude="shop.*" --nsExclude="shop.sessions"

# One collection, filtered
mongodump --uri="$URI" --db=shop --collection=orders \
  --query='{"status":"paid"}' --out=./dump

# Restore, dropping targets first
mongorestore --uri="$URI" --archive=shop.gz --gzip --drop --oplogReplay

# Rename on the way in
mongorestore --uri="$URI" --archive=shop.gz --gzip \
  --nsFrom="shop.*" --nsTo="shop_staging.*"

# Copy between clusters with no file on disk
mongodump --uri="$SRC" --archive --gzip | mongorestore --uri="$DST" --archive --gzip

mongoexport --uri="$URI" --collection=orders --type=csv \
  --fields=ref,status,total --out=orders.csv
mongoexport --uri="$URI" --collection=orders --jsonArray \
  --query='{"status":"paid"}' --out=orders.json

mongoimport --uri="$URI" --collection=orders --type=csv --headerline \
  --file=orders.csv
mongoimport --uri="$URI" --collection=orders --mode=upsert \
  --upsertFields=ref --file=orders.json
mongoimport --uri="$URI" --collection=orders --jsonArray \
  --numInsertionWorkers=4 --file=orders.json

use admin
db.createUser({
  user: "app",
  pwd: passwordPrompt(),                  // never inline the password
  roles: [ { role: "readWrite", db: "shop" },
           { role: "read",      db: "analytics" } ]
})

db.grantRolesToUser("app", [ { role: "dbAdmin", db: "shop" } ])
db.revokeRolesFromUser("app", [ { role: "read", db: "analytics" } ])
db.changeUserPassword("app", passwordPrompt())
db.updateUser("app", { roles: [ { role: "read", db: "shop" } ] })
db.getUser("app", { showPrivileges: true })
db.dropUser("app")
show users

// Least privilege, custom role
db.createRole({
  role: "ordersReader",
  privileges: [ { resource: { db: "shop", collection: "orders" },
                  actions: ["find"] } ],
  roles: []
})

rs.initiate()                             // one-node set, for local dev
rs.status()                               // members, state, lag, election info
rs.conf()                                 // the configuration document
rs.add("db2.internal:27017")
rs.add({ host: "db3:27017", priority: 0, hidden: true })   // analytics node
rs.remove("db3:27017")
rs.stepDown(60)                           // yield PRIMARY for 60s, triggers election
rs.hello()                                // replaces the old isMaster
rs.printReplicationInfo()                 // oplog size and the time window it covers
rs.printSecondaryReplicationInfo()        // per-secondary lag

db.getMongo().setReadPref("secondaryPreferred")
db.orders.find().readPref("nearest", [{ region: "eu" }])   // with a tag set

const cs = db.orders.watch(
  [ { $match: { operationType: { $in: ["insert", "update"] },
                "fullDocument.status": "paid" } },
    { $project: { _id: 1, operationType: 1, "fullDocument.ref": 1 } } ],
  { fullDocument: "updateLookup" }
);

while (!cs.isClosed()) {
  if (cs.hasNext()) {
    const change = cs.next();
    printjson(change);
    saveToken(change._id);          // the resume token
  }
}
cs.close();

sh.status()
sh.enableSharding("shop")
sh.shardCollection("shop.orders", { customer_id: "hashed" })
sh.shardCollection("shop.events", { tenant_id: 1, created_at: 1 })

db.adminCommand({ refineCollectionShardKey: "shop.orders",
                  key: { customer_id: 1, ref: 1 } })       // 4.4+, suffix only
db.adminCommand({ reshardCollection: "shop.orders",
                  key: { tenant_id: 1, created_at: 1 } })  // 5.0+, full rewrite
sh.balancerStatus()
sh.stopBalancer()
sh.moveCollection("shop.settings", "shard02")     // 8.0+, unsharded collections
db.adminCommand({ unshardCollection: "shop.orders" })      // 8.0+

mongofiles --uri="$URI" --db=media put report.pdf
mongofiles --uri="$URI" --db=media list
mongofiles --uri="$URI" --db=media get report.pdf

db.fs.files.find({ filename: "report.pdf" })
db.fs.chunks.countDocuments({ files_id: fileId })