mongoコマンド チートシート

# ローカルホストのデフォルトポート (27017) に接続
mongo
# ホストとポートを指定して接続
mongo --host myhost.example.com --port 27018
# ユーザー認証して接続
mongo --host myhost --port 27017 -u myUser -p myPassword --authenticationDatabase admin
# 特定のデータベースに接続
mongo mydatabase
# URI を使用して接続 (推奨)
mongo "mongodb://myUser:myPassword@myhost:27017/mydatabase?authSource=admin"

show dbs

use myAppDb

db

show collections

db.version()

db.serverStatus()

db.stats()

help

db.users.help()

cls

clear

exit

quit()

// setup.js ファイルを実行
load("setup.js")

// newDb が存在しなければ、後続のデータ挿入時に作成される
use newDb

// 現在のデータベースを削除
db.dropDatabase()

db.getName()

db.getCollectionNames()

// localhost の backupDb を現在のデータベースにコピー
db.copyDatabase("backupDb", db.getName())
// remotehost の sourceDb を現在のデータベースにコピー
db.copyDatabase("sourceDb", db.getName(), "remotehost.example.com")

// remotehost.example.com から現在のデータベースと同じ名前のデータベースを複製
db.cloneDatabase("remotehost.example.com")

// 基本的なコレクション作成
db.createCollection("users")
// Capped Collection (サイズ 1MB, 最大 1000 ドキュメント) を作成
db.createCollection("logs", { capped: true, size: 1048576, max: 1000 })
// バリデーションルール付きでコレクション作成
db.createCollection("products", { validator: { $jsonSchema: { bsonType: "object", required: [ "name", "price" ], properties: { name: { bsonType: "string", description: "must be a string and is required" }, price: { bsonType: "double", minimum: 0, description: "must be a double and is required" }, stock: { bsonType: "int" } } } }, validationLevel: "strict", // moderate もしくは off validationAction: "error" // warn もしくは error
})

// users コレクションを削除
db.users.drop()

// users コレクションを customers にリネーム
db.users.renameCollection("customers")
// logs コレクションを old_logs にリネーム (old_logs が存在すれば上書き)
db.logs.renameCollection("old_logs", true)

// "user-profiles" という名前のコレクションを取得
var profiles = db.getCollection("user-profiles")
profiles.find()

db.products.stats()

db.logs.storageSize()

db.users.totalSize()

// 基本的な検証
db.orders.validate()
// 詳細な検証
db.orders.validate({ full: true })

// events コレクションを 10MB の Capped Collection に変換
db.events.convertToCapped(10 * 1024 * 1024)

// 単一ドキュメントの挿入
db.users.insertOne({ name: "Alice", age: 30, city: "New York" })
// Write Concern を指定して挿入 (レプリカセット環境で重要)
db.products.insertOne( { item: "pencil", qty: 50 }, { writeConcern: { w: "majority", wtimeout: 5000 } }
)

// 複数ドキュメントの挿入
db.users.insertMany([ { name: "Bob", age: 25, city: "London" }, { name: "Charlie", age: 35, city: "Paris" }
])
// 順序指定なしで挿入 (エラーが発生しても継続)
db.inventory.insertMany( [ { item: "notebook", qty: 100 }, { _id: 1, item: "pen", qty: 200 }, // 既存の_idと重複する可能性 { item: "eraser", qty: 50 } ], { ordered: false }
)

// 単一 (非推奨)
db.legacy.insert({ status: "active" })
// 複数 (非推奨)
db.legacy.insert([ { code: 1 }, { code: 2 } ])

// _id がないので挿入される
db.items.save({ name: "itemA", value: 10 })
// _id が存在し、コレクション内に対応するドキュメントがあれば更新、なければ挿入
var existingItem = db.items.findOne({ name: "itemA" });
if (existingItem) { existingItem.value = 15; db.items.save(existingItem); // 更新
}
db.items.save({ _id: ObjectId("..."), name: "itemB", value: 20 }) // _id が存在すれば更新、なければ挿入

// 全てのドキュメントを検索
db.users.find()
// city が "New York" のドキュメントを検索
db.users.find({ city: "New York" })
// age が 30 より大きいドキュメントを検索
db.users.find({ age: { $gt: 30 } })
// name と email フィールドのみを返す ( _id はデフォルトで返される)
db.users.find({ city: "London" }, { name: 1, email: 1 })
// name と email フィールドのみを返し、_id は返さない
db.users.find({ city: "London" }, { name: 1, email: 1, _id: 0 })

// name が "Alice" の最初のドキュメントを取得
db.users.findOne({ name: "Alice" })
// city が "Paris" で、name フィールドのみを取得 (_idも返る)
db.users.findOne({ city: "Paris" }, { name: 1 })

// age が 25 以上のユーザーを age の昇順でソートし、最初の 5 件を取得
db.users.find({ age: { $gte: 25 } }).sort({ age: 1 }).limit(5)
// city が "New York" のユーザーを name の降順でソートし、最初の 2 件をスキップして次の 10 件を取得
db.users.find({ city: "New York" }).sort({ name: -1 }).skip(2).limit(10)
// 条件に一致するドキュメント数を取得 (v4.0以降は countDocuments/estimatedDocumentCount 推奨)
db.users.find({ status: "active" }).count()
// 結果を整形して表示
db.products.find({ category: "electronics" }).pretty()

// status が "active" のドキュメント数を正確にカウント
db.users.countDocuments({ status: "active" })
// age が 30 より大きいドキュメント数をカウント
db.users.countDocuments({ age: { $gt: 30 } })

// コレクションの全ドキュメント数を高速に推定
db.logs.estimatedDocumentCount()

// users コレクション内の全てのユニークな city のリストを取得
db.users.distinct("city")
// status が "active" のユーザーのユニークな department のリストを取得
db.users.distinct("department", { status: "active" })

// name が "Alice" の最初のユーザーの age を 31 に、city を "San Francisco" に更新
db.users.updateOne( { name: "Alice" }, { $set: { age: 31, city: "San Francisco" }, $currentDate: { lastModified: true } }
)
// item が "pen" の最初の在庫の qty を 10 増やす
db.inventory.updateOne( { item: "pen" }, { $inc: { qty: 10 } }
)
// email が "new@example.com" のユーザーを探し、なければ挿入 (upsert)
db.users.updateOne( { email: "new@example.com" }, { $set: { name: "New User", status: "pending" }, $setOnInsert: { createdAt: new Date() } }, { upsert: true }
)

// city が "London" の全てのユーザーの status を "inactive" に更新
db.users.updateMany( { city: "London" }, { $set: { status: "inactive" }, $currentDate: { lastModified: true } }
)
// 全ての商品の価格を 10% 引き上げる (少数誤差に注意)
db.products.updateMany( {}, { $mul: { price: 1.1 } }
)
// qty が 0 未満の全ての在庫に "low_stock" タグを追加 (重複なし)
db.inventory.updateMany( { qty: { $lt: 0 } }, { $addToSet: { tags: "low_stock" } }
)

// name が "Charlie" の最初のユーザーのドキュメント全体を置き換え (_id は維持される)
db.users.replaceOne( { name: "Charlie" }, { name: "Charles", age: 36, city: "Lyon", status: "active", lastModified: new Date() }
)
// sku が "XYZ" の商品を置き換え、なければ挿入 (upsert)
db.products.replaceOne( { sku: "XYZ" }, { sku: "XYZ", name: "New Product", price: 99.99, category: "new" }, { upsert: true }
)

// 最初の status が "pending" のドキュメントを "active" に更新 (非推奨)
db.orders.update({ status: "pending" }, { $set: { status: "active" } })
// 全ての status が "shipped" のドキュメントに shippedDate を追加 (非推奨)
db.orders.update( { status: "shipped" }, { $currentDate: { shippedDate: true } }, { multi: true }
)
// user_id が 123 の設定を探し、なければ挿入 (非推奨)
db.settings.update( { user_id: 123 }, { $set: { theme: "dark", notifications: true } }, { upsert: true }
)

// 'processed' フィールドが false の最も古い (ts 昇順) ドキュメントを探し、
// 'processed' を true に更新し、更新後のドキュメントを返す
db.queue.findAndModify({ query: { processed: false }, sort: { ts: 1 }, update: { $set: { processed: true, processing_time: new Date() } }, new: true // 更新後のドキュメントを返す (デフォルトは false で更新前を返す)
})
// 'counter_name' が 'user_id' のカウンターを探し、値を 1増やし、更新後の値を返す
db.counters.findAndModify({ query: { counter_name: 'user_id' }, update: { $inc: { value: 1 } }, new: true, upsert: true // カウンターが存在しない場合は作成する
})
// 'status' が 'temporary' のドキュメントを検索し、削除して、削除されたドキュメントを返す
db.temp_files.findAndModify({ query: { status: 'temporary' }, remove: true
})

// status が "pending" のドキュメントを score の降順で探し、
// status を "processing" に更新し、更新前のドキュメントを返す
db.tasks.findOneAndUpdate( { status: "pending" }, { $set: { status: "processing", startTime: new Date() } }, { sort: { score: -1 }, returnOriginal: true } // MongoDB 3.2+ では returnDocument: "before"
)
// 上記と同じ操作で、更新後のドキュメントを返す (デフォルトは更新前)
db.tasks.findOneAndUpdate( { status: "pending" }, { $set: { status: "processing", startTime: new Date() } }, { sort: { score: -1 }, returnNewDocument: true } // MongoDB 3.2+ では returnDocument: "after"
)

// sessionId が "abc" のセッションデータを新しいデータで置き換え、
// 置換後のドキュメントを返す。なければ挿入する (upsert)。
db.sessions.findOneAndReplace( { sessionId: "abc" }, { sessionId: "abc", userId: "user1", data: { theme: "light" }, expires: new Date(...) }, { upsert: true, returnNewDocument: true } // MongoDB 3.2+ では returnDocument: "after"
)

// name が "Bob" の最初のユーザーを削除
db.users.deleteOne({ name: "Bob" })
// status が "inactive" で lastLogin が特定の日付より前の最初のドキュメントを削除
db.users.deleteOne({ status: "inactive", lastLogin: { $lt: new Date("2023-01-01") } })

// city が "Paris" の全てのユーザーを削除
db.users.deleteMany({ city: "Paris" })
// logs コレクションから、timestamp が特定の日付より古い全てのログを削除
db.logs.deleteMany({ timestamp: { $lt: new Date("2024-01-01T00:00:00Z") } })
// コレクションの全ドキュメントを削除 (通常は drop() の方が効率的)
db.temporaryData.deleteMany({})

// status が "cancelled" の全ての注文を削除 (非推奨)
db.orders.remove({ status: "cancelled" })
// type が "spam" の最初のコメントを削除 (非推奨)
db.comments.remove({ type: "spam" }, true)
// または
db.comments.remove({ type: "spam" }, { justOne: true })

// status が "ready" のタスクを優先度 (priority) の高い順に探し、
// 最初のタスクを削除して、その内容 (jobId フィールドのみ) を返す
db.jobQueue.findOneAndDelete( { status: "ready" }, { sort: { priority: -1 }, projection: { jobId: 1, _id: 0 } }
)

// userId フィールドに昇順インデックスを作成
db.users.createIndex({ userId: 1 })
// email フィールドにユニーク制約付きの昇順インデックスを作成 (バックグラウンドで実行)
db.users.createIndex({ email: 1 }, { unique: true, background: true })
// lastName 昇順、firstName 降順の複合インデックスを作成し、インデックス名を指定
db.users.createIndex({ lastName: 1, firstName: -1 }, { name: "name_index" })
// createdAt フィールドに TTL インデックスを作成 (ドキュメントが 1 時間後に自動削除される)
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 })
// location フィールドに 2dsphere インデックスを作成 (地理空間クエリ用)
db.places.createIndex({ location: "2dsphere" })
// description フィールドにテキストインデックスを作成 (全文検索用)
db.articles.createIndex({ title: "text", content: "text" })

db.users.getIndexes()

// 名前でインデックスを削除
db.users.dropIndex("email_1") // email フィールドの昇順インデックス (デフォルト名)
// 名前でインデックスを削除 (カスタム名)
db.users.dropIndex("name_index")
// キードキュメントでインデックスを削除
db.users.dropIndex({ userId: 1 })

// users コレクションの _id 以外の全インデックスを削除
db.users.dropIndexes()

db.largeCollection.reIndex()

db.users.totalIndexSize()

// 各都市 (city) ごとのユーザー数を計算し、ユーザー数が多い順にソート
db.users.aggregate([ { $group: { _id: "$city", count: { $sum: 1 } } }, { $sort: { count: -1 } }
])
// status が "A" の注文について、顧客 (cust_id) ごとの合計金額 (totalAmount) を計算
db.orders.aggregate([ { $match: { status: "A" } }, { $group: { _id: "$cust_id", totalAmount: { $sum: "$amount" } } }
])
// 各商品の平均価格、最高価格、最低価格を計算
db.products.aggregate([ { $group: { _id: null, // 全てのドキュメントを一つのグループに avgPrice: { $avg: "$price" }, maxPrice: { $max: "$price" }, minPrice: { $min: "$price" } } }
])
// タグ配列を展開し、各タグの出現回数をカウント
db.articles.aggregate([ { $unwind: "$tags" }, { $group: { _id: "$tags", count: { $sum: 1 } } }, { $sort: { count: -1 } }
])
// orders コレクションと products コレクションを productId で結合
db.orders.aggregate([ { $lookup: { from: "products", // 結合するコレクション localField: "productId", // orders コレクションのフィールド foreignField: "prod_id", // products コレクションのフィールド as: "productDetails" // 結合結果を格納するフィールド名 } }
])
// 集計結果を新しいコレクション 'city_user_counts' に出力
db.users.aggregate([ { $group: { _id: "$city", count: { $sum: 1 } } }, { $out: "city_user_counts" }
])
// 2023 年以降の注文について、月ごとに合計売上を計算し、
// 結果を 'monthly_sales' コレクションにマージ (月が存在すれば更新、なければ挿入)
db.orders.aggregate([ { $match: { orderDate: { $gte: new Date("2023-01-01") } } }, { $group: { _id: { $dateToString: { format: "%Y-%m", date: "$orderDate" } }, // "YYYY-MM" 形式 totalSales: { $sum: "$amount" } } }, { $sort: { _id: 1 } }, { $merge: { into: "monthly_sales", on: "_id", // _id フィールド (月) でマッチング whenMatched: "replace", // マッチしたらドキュメントを置き換える whenNotMatched: "insert" // マッチしなかったら挿入する } }
])

db.users.aggregate([ { $match: { status: "active" } }, { $group: { _id: "$department", count: { $sum: 1 } } }
]).explain("executionStats") // "queryPlanner", "executionStats", "allPlansExecution"

// admin データベースに管理者ユーザーを作成
use admin
db.createUser({ user: "myAdmin", pwd: passwordPrompt(), // シェルがパスワード入力を求める roles: [ { role: "userAdminAnyDatabase", db: "admin" }, "readWriteAnyDatabase" ]
})
// myAppDb データベースに読み取り専用ユーザーを作成
use myAppDb
db.createUser({ user: "appReader", pwd: "securePassword123", roles: [ { role: "read", db: "myAppDb" } ]
})
// myAppDb データベースに読み書きユーザーを作成
use myAppDb
db.createUser({ user: "appWriter", pwd: passwordPrompt(), roles: [ "readWrite" ] // db が指定されない場合、現在のデータベース (myAppDb) が対象
})

// appWriter ユーザーのパスワードを変更 (myAppDb で実行)
use myAppDb
db.updateUser("appWriter", { pwd: passwordPrompt() })
// appWriter ユーザーに backup ロールを追加 (admin DB のロール)
use myAppDb
db.updateUser("appWriter", { $push: { roles: { role: "backup", db: "admin" } }
})
// myAdmin ユーザーのカスタムデータを更新 (admin DB で実行)
use admin
db.updateUser("myAdmin", { $set: { customData: { employeeId: "E12345" } }
})

// appReader ユーザーのパスワードを変更 (myAppDb で実行)
use myAppDb
db.changeUserPassword("appReader", passwordPrompt())

// appWriter ユーザーを myAppDb から削除
use myAppDb
db.dropUser("appWriter")

// myAppDb から全ユーザーを削除 (実行前に要確認！)
use myAppDb
// db.dropAllUsers() // コメントアウト解除して実行

// myAdmin ユーザーの情報を取得 (admin DB で実行)
use admin
db.getUser("myAdmin")
// appReader ユーザーの情報をロール情報も含めて取得 (myAppDb で実行)
use myAppDb
db.getUser("appReader", { showPrivileges: true })

// 現在のデータベース (例: myAppDb) の全ユーザーを取得
use myAppDb
db.getUsers()
// admin データベースの全ユーザーを取得
use admin
db.getUsers()

// myAppDb でアイテム管理用ロールを作成 (admin DB で実行 or myAppDb で実行)
use myAppDb // または use admin
db.createRole({ role: "itemManager", privileges: [ { resource: { db: "myAppDb", collection: "items" }, actions: [ "find", "update", "insert" ] }, { resource: { db: "myAppDb", collection: "inventory" }, actions: [ "find" ] } ], roles: [] // 他のロールを継承しない場合
})

// itemManager ロールに inventory コレクションへの insert 権限を追加 (myAppDb で実行)
use myAppDb
db.updateRole("itemManager", { $push: { privileges: { resource: { db: "myAppDb", collection: "inventory" }, actions: [ "insert" ] } }
})

// itemManager ロールを myAppDb から削除
use myAppDb
db.dropRole("itemManager")

// myAppDb から全カスタムロールを削除
use myAppDb
db.dropAllRoles()

// itemManager ロールの情報を権限も含めて取得 (myAppDb で実行)
use myAppDb
db.getRole("itemManager", { showPrivileges: true })
// 組み込みロール readWrite の情報を取得 (任意の DB で可)
db.getRole("readWrite", { showPrivileges: true, showBuiltinRoles: true })

// 現在のデータベース (例: myAppDb) の全カスタムロールを取得
use myAppDb
db.getRoles()
// 現在のデータベースの全ロール (カスタム + 組み込み) を取得
use myAppDb
db.getRoles({ showBuiltinRoles: true })

// appReader ユーザーに itemManager ロールを追加 (myAppDb で実行)
use myAppDb
db.grantRolesToUser("appReader", [ "itemManager" ]) // ロール名のみ、現在のDBのロール
// または
db.grantRolesToUser("appReader", [ { role: "itemManager", db: "myAppDb" } ])

// appReader ユーザーから itemManager ロールを削除 (myAppDb で実行)
use myAppDb
db.revokeRolesFromUser("appReader", [ "itemManager" ])
// または
db.revokeRolesFromUser("appReader", [ { role: "itemManager", db: "myAppDb" } ])

// itemManager ロールにログコレクションへの find 権限を追加 (myAppDb で実行)
use myAppDb
db.grantPrivilegesToRole("itemManager", [ { resource: { db: "myAppDb", collection: "logs" }, actions: [ "find" ] }
])

// itemManager ロールから inventory コレクションへの insert 権限を削除 (myAppDb で実行)
use myAppDb
db.revokePrivilegesFromRole("itemManager", [ { resource: { db: "myAppDb", collection: "inventory" }, actions: [ "insert" ] }
])

// appReader として myAppDb に認証
use myAppDb
db.auth("appReader", "securePassword123")
// またはパスワードプロンプトを使用
db.auth("appReader", passwordPrompt())

db.logout()

rs.status()

rs.conf()

// 単純な3メンバー構成で初期化 (例)
var config = { _id: "myReplicaSet", members: [ { _id: 0, host: "mongo1.example.com:27017" }, { _id: 1, host: "mongo2.example.com:27017" }, { _id: 2, host: "mongo3.example.com:27017" } ]
};
rs.initiate(config);

// 新しいデータノードを追加
rs.add("mongo4.example.com:27017")
// 新しいアービターを追加
rs.add("arbiter1.example.com:27017", true)

rs.remove("mongo4.example.com:27017")

// 設定を取得して変更し、再設定
var cfg = rs.conf();
// cfg の内容を変更 (例: メンバーの優先度変更など)
// cfg.members[1].priority = 2;
rs.reconfig(cfg);

// 60秒間プライマリにならないようにして降格
rs.stepDown(60)

// 120秒間プライマリにならないようにする
rs.freeze(120)

// mongo2.example.com:27017 から同期する
rs.syncFrom("mongo2.example.com:27017")

sh.status()
sh.status(true) // 詳細表示

// レプリカセット rs1 をシャードとして追加
sh.addShard("rs1/mongo-rs1-1:27018,mongo-rs1-2:27018")
// スタンドアロンインスタンスをシャードとして追加 (非推奨)
sh.addShard("mongo-sa:27019", "shardStandalone")

// myBigDb データベースのシャーディングを有効にする
sh.enableSharding("myBigDb")

// myBigDb.users コレクションを userId フィールドでシャーディング (ハッシュベース)
sh.shardCollection("myBigDb.users", { userId: "hashed" })
// myBigDb.orders コレクションを orderId フィールドでシャーディング (レンジベース)
sh.shardCollection("myBigDb.orders", { orderId: 1 })
// 複合シャードキーでシャーディング
sh.shardCollection("myBigDb.events", { customerId: 1, eventTimestamp: 1 })

// shard0001 シャードの削除プロセスを開始
sh.removeShard("shard0001")

// バランサーを開始
sh.startBalancer()
// バランサーを停止 (60000ms=1分 待機)
sh.stopBalancer(60000)

sh.getBalancerState()
sh.isBalancerRunning()

// myBigDb.users コレクションで userId が 100 のドキュメントを含むチャンクを shard0002 に移動
sh.moveChunk("myBigDb.users", { userId: 100 }, "shard0002")

// find クエリの実行計画 (インデックス使用状況など)
db.users.find({ city: "New York", age: { $gt: 30 } }).explain()
// find クエリの実行統計情報 (実行時間、スキャンしたドキュメント数など)
db.users.find({ city: "New York" }).sort({ name: 1 }).explain("executionStats")
// update クエリの実行計画
db.products.updateMany({ inStock: false }, { $set: { status: "discontinued" } }).explain()

// 現在実行中の全ての操作を表示
db.currentOp()
// アクティブな操作のみを表示
db.currentOp(true)
// または
db.currentOp({ "active": true })
// 特定のコレクションに対する操作を表示
db.currentOp({ "ns": "myDb.myCollection" })
// 10秒以上実行されている操作を表示
db.currentOp({ "secs_running": { $gt: 10 } })

// opid が 12345 の操作を終了
db.killOp(12345)

// 50ms より遅い操作をプロファイル
db.setProfilingLevel(1, 50)
// すべての操作をプロファイル
db.setProfilingLevel(2)
// プロファイリングを無効化
db.setProfilingLevel(0)

db.getProfilingStatus()

// プロファイル結果を表示
db.system.profile.find().pretty()
// 遅いクエリ (type: "query", millis > 100) を表示
db.system.profile.find({ op: "query", millis: { $gt: 100 } }).sort({ ts: -1 })

// 現在の接続でセカンダリからの読み取りを許可
db.setSecondaryOk()
// または
rs.secondaryOk()

// 新しい ObjectId を生成
var newId = ObjectId()
print(newId)
// 特定の ObjectId を持つドキュメントを検索
db.myCollection.findOne({ _id: ObjectId("605c7d7b8f8d7a001f2b3c4d") })

// 現在の日時で Date オブジェクトを生成
var now = ISODate()
print(now)
// 特定の日時で Date オブジェクトを生成
var specificDate = ISODate("2024-03-15T10:30:00Z")
db.events.insertOne({ event: "meeting", time: specificDate })
// 特定の日付より後のドキュメントを検索
db.logs.find({ timestamp: { $gt: ISODate("2024-01-01T00:00:00Z") } })