MongoDB

docker pull mongo

docker volume create mongodb_data

docker run --name mongodb -d -p 27017:27017 -v mongodb_data:/data/db -e MONGO_INITDB_ROOT_USERNAME=username -e MONGO_INITDB_ROOT_PASSWORD=password mongo

ACID BASE
原子性(Atomicity) 基本可用(Basically Available)
一致性(Consistency) 软状态/柔性事务(Soft state)
隔离性(Isolation) 最终一致性 (Eventual consistency)
持久性 (Durable)  

类型 部分代表    特点
列存储 Hbase Cassandra Hypertable 顾名思义，是按列存储数据的。最大的特点是方便存储结构化和半结构化数据，方便做数据压缩，对针对某一列或者某几列的查询有非常大的IO优势。

文档存储    MongoDB CouchDB 文档存储一般用类似json的格式存储，存储的内容是文档型的。这样也就有机会对某些字段建立索引，实现关系数据库的某些功能。

key-value存储   Tokyo Cabinet / Tyrant  Berkeley DB MemcacheDB  Redis 可以通过key快速查询到其value。一般来说，存储不管value的格式，照单全收。（Redis包含了其他功能）

图存储  Neo4J FlockDB 图形关系的最佳存储。使用传统关系数据库来解决的话性能低下，而且设计使用不方便。

对象存储 db4o Versant 通过类似面向对象语言的语法操作数据库，通过对象的方式存取数据。

xml数据库 Berkeley DB XML BaseX 高效的存储XML数据，并支持XML的内部查询语法，比如XQuery,Xpath。

向量数据库 Milvus FAISS (Facebook AI Similarity Search) 专门为存储和检索高维向量数据设计的，主要用于相似性搜索、机器学习和推荐系统等场景。

docker exec -it mongodb  bash

mongosh --username <username> --password <password> --authenticationDatabase <authDatabase>
<username>：登录的用户名。
<password>：对应用户的密码。
<authDatabase>：用户所在的认证数据库（通常是 admin）。

root@0b390d7bbbf5:/# mongosh --username admin --password password  --auth
enticationDatabase admin         
Current Mongosh Log ID: 67e0d04f1cb0159f446b140a
Connecting to:          mongodb://<credentials>@127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&authSource=admin&appName=mongosh+2.4.2
Using MongoDB:          8.0.5
Using Mongosh:          2.4.2

For mongosh info see: https://www.mongodb.com/docs/mongodb-shell/

------
   The server generated these startup warnings when booting
   2025-03-24T03:18:38.403+00:00: Using the XFS filesystem is strongly recommended with the WiredTiger storage engine. See http://dochub.mongodb.org/core/prodnotes-filesystem
   2025-03-24T03:18:39.904+00:00: For customers running the current memory allocator, we suggest changing the contents of the following sysfsFile
   2025-03-24T03:18:39.904+00:00: For customers running the current memory allocator, we suggest changing the contents of the following sysfsFile
   2025-03-24T03:18:39.904+00:00: We suggest setting the contents of sysfsFile to 0.
   2025-03-24T03:18:39.904+00:00: vm.max_map_count is too low
------

test> 

test> show dbs
admin   100.00 KiB
config   12.00 KiB
local    72.00 KiB
test> 

test> use myDB
switched to db myDB
myDB> 

myDB> db.myCollection.insertOne({name:"example", value: 1});
{
  acknowledged: true,
  insertedId: ObjectId('67e0d1b01cb0159f446b140b')
}

myDB> db.myCollection.find()
[
  {
    _id: ObjectId('67e0d1b01cb0159f446b140b'),
    name: 'example',
    value: 1
  }
]

myDB> db.myCollection.updateOne({name:"example"}, {$set: {age: 31}})
{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0
}
myDB> db.myCollection.updateOne({name:"example"}, {$set: {value: 31}})
{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0
}
myDB> db.myCollection.find()
[
  {
    _id: ObjectId('67e0d1b01cb0159f446b140b'),
    name: 'example',
    value: 31,
    age: 31
  }
]

myDB> db.myCollection.find()
[
  {
    _id: ObjectId('67e0d1b01cb0159f446b140b'),
    name: 'example',
    value: 31,
    age: 31
  }
]
myDB> db.myCollection.deleteOne({name:"example"})
{ acknowledged: true, deletedCount: 1 }
myDB> db.myCollection.find()

myDB> quit()
root@0b390d7bbbf5:/# 

root@0b390d7bbbf5:/# mongosh --username admin --password password  --authenticationDatabase admin
Current Mongosh Log ID: 67e10c18acf1cfe11a6b140a
Connecting to:          mongodb://<credentials>@127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&authSource=admin&appName=mongosh+2.4.2
Using MongoDB:          8.0.5
Using Mongosh:          2.4.2

For mongosh info see: https://www.mongodb.com/docs/mongodb-shell/

------
   The server generated these startup warnings when booting
   2025-03-24T03:18:38.403+00:00: Using the XFS filesystem is strongly recommended with the WiredTiger storage engine. See http://dochub.mongodb.org/core/prodnotes-filesystem
   2025-03-24T03:18:39.904+00:00: For customers running the current memory allocator, we suggest changing the contents of the following sysfsFile
   2025-03-24T03:18:39.904+00:00: For customers running the current memory allocator, we suggest changing the contents of the following sysfsFile
   2025-03-24T03:18:39.904+00:00: We suggest setting the contents of sysfsFile to 0.
   2025-03-24T03:18:39.904+00:00: vm.max_map_count is too low
------

# 查看当前所使用的数据库
test> db
test
# 查看实例中的数据库
test> show dbs
admin   100.00 KiB
config   60.00 KiB
local    72.00 KiB
myDB     24.00 KiB
# 切换数据库
test> use myDB
switched to db myDB
myDB> 

db.createCollection("mycoll", {capped:true, size:100000})

"mycoll"：
  要创建的集合名称。

capped: true：
  指定集合为固定集合。
  固定集合是一种特殊类型的集合，具有固定的大小，数据以先进先出的方式存储。
  当集合达到指定大小时，旧的数据会被自动覆盖。

size: 100000：
  指定固定集合的最大大小（以字节为单位）。
  这里表示集合的最大大小为 100,000 字节（约 100 KB）。
  如果集合大小超过此限制，旧的数据会被覆盖。

dbname.system.*

test> use myDB
switched to db myDB
# 列出所有集合名称
myDB> db.getCollectionNames()
[ 'myCollection' ]
# 列出集合的索引
myDB> db.myCollection.getIndexes()
[ { v: 2, key: { _id: 1 }, name: '_id_' } ]

admin> use myDB
switched to db myDB
myDB> var newObject = ObjectId()

myDB> newObject.getTimestamp()
ISODate('2025-03-24T08:22:33.000Z')

myDB> newObject.toString()
67e11649b2807af16b6b140b
myDB> 

myDB> var mydate1 = new Date()

myDB> mydate1
ISODate('2025-03-24T08:27:22.279Z')
myDB> typeof mydate1
object

myDB> var mydate2 = ISODate()

myDB> mydate2
ISODate('2025-03-24T08:28:18.389Z')
myDB> typeof mydate2
object

myDB> var mydate1str = mydate1.toString()

myDB> mydate1str
Mon Mar 24 2025 08:27:22 GMT+0000 (Coordinated Universal Time)
myDB> typeof mydate1str
string

myDB> Date()
Mon Mar 24 2025 08:30:28 GMT+0000 (Coordinated Universal Time)

use <database_name>

db.createUser({
  user: "testuser",
  pwd: "password123",
  roles: [
    { role: "readWrite", db: "<database_name>" },
    { role: "dbAdmin", db: "<database_name>" }
  ]
})

# db.createUser({user:"myDbTest",pwd:"password", roles:[{role: "readWrite", db: "myDB"}, {role: "dbAdmin", db: "myDB"}]})

myDB> use admin
switched to db admin
admin> db.createUser({user:"myDbTest",pwd:"password", roles:[{role: "readWrite", db: "myDB"}, {rrole: "dbAdmin", db: "myDB"}]})
{ ok: 1 }
admin> exit
root@0b390d7bbbf5:/# mongosh --username "myDbTest"  --authenticationDatabase admin
Enter password: ********
Current Mongosh Log ID: 67e123fa9950d4d66b6b140a
Connecting to:          mongodb://<credentials>@127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&authSource=admin&appName=mongosh+2.4.2
Using MongoDB:          8.0.5
Using Mongosh:          2.4.2

For mongosh info see: https://www.mongodb.com/docs/mongodb-shell/

test> use myDB
switched to db myDB

test> use admin
switched to db admin
admin> db.auth("myDbTest", "password")
{ ok: 1 }

security:
  authorization: "enabled"

root@0b390d7bbbf5:/# mongosh --username "admin"  --authenticationDatabase admin
Enter password: ********
Current Mongosh Log ID: 67e1246ee059d2da046b140a
Connecting to:          mongodb://<credentials>@127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&authSource=admin&appName=mongosh+2.4.2
Using MongoDB:          8.0.5
Using Mongosh:          2.4.2

For mongosh info see: https://www.mongodb.com/docs/mongodb-shell/

------
   The server generated these startup warnings when booting
   2025-03-24T03:18:38.403+00:00: Using the XFS filesystem is strongly recommended with the WiredTiger storage engine. See http://dochub.mongodb.org/core/prodnotes-filesystem
   2025-03-24T03:18:39.904+00:00: For customers running the current memory allocator, we suggest changing the contents of the following sysfsFile
   2025-03-24T03:18:39.904+00:00: For customers running the current memory allocator, we suggest changing the contents of the following sysfsFile
   2025-03-24T03:18:39.904+00:00: We suggest setting the contents of sysfsFile to 0.
   2025-03-24T03:18:39.904+00:00: vm.max_map_count is too low
------

test> use admin
switched to db admin
admin> db.dropUser("myDbTest")
{ ok: 1 }

mongodb://[username:password@]host1[:port1][,...hostN[:portN]][/[defaultauthdb][?options]]

mongodb://：协议头，表示使用 MongoDB。
[username:password@]：（可选）认证信息，包括用户名和密码。
host1[:port1][,...hostN[:portN]]：服务器地址和端口，可以是一个或多个 MongoDB 服务器的地址和端口。
/[defaultauthdb]：（可选）默认认证数据库。
[?options]：（可选）连接选项。
authSource：指定认证数据库。
replicaSet：指定副本集的名称。
ssl：启用 SSL 连接（true 或 false）。
readPreference：指定读偏好，如 primary, primaryPreferred, secondary, secondaryPreferred, nearest。
connectTimeoutMS：指定连接超时时间（毫秒）。
socketTimeoutMS：指定套接字超时时间（毫秒）。

mongodb://localhost

mongodb://localhost/mydatabase

mongodb://username:password@localhost/mydatabase

mongodb://remotehost:27017

mongodb://host1:27017,host2:27017,host3:27017/mydatabase?replicaSet=myReplicaSet

mongodb://username:password@localhost:27017/mydatabase?ssl=true

mongodb://username:password@localhost:27017/mydatabase?authSource=admin&ssl=true

#连接本地数据库服务器，端口是默认的。
mongodb://localhost
#使用用户名fred，密码foobar登录localhost的admin数据库。
mongodb://fred:foobar@localhost
#使用用户名fred，密码foobar登录localhost的baz数据库。
mongodb://fred:foobar@localhost/baz
#连接 replica pair, 服务器1为example1.com服务器2为example2。
mongodb://example1.com:27017,example2.com:27017
#连接 replica set 三台服务器 (端口 27017, 27018, 和27019):
mongodb://localhost,localhost:27018,localhost:27019
#连接 replica set 三台服务器, 写入操作应用在主服务器 并且分布查询到从服务器。
mongodb://host1,host2,host3/?slaveOk=true
#直接连接第一个服务器，无论是replica set一部分或者主服务器或者从服务器。
mongodb://host1,host2,host3/?connect=direct;slaveOk=true
#当你的连接服务器有优先级，还需要列出所有服务器，你可以使用上述连接方式。
#安全模式连接到localhost:
mongodb://localhost/?safe=true
#以安全模式连接到replica set，并且等待至少两个复制服务器成功写入，超时时间设置为2秒。
mongodb://host1,host2,host3/?safe=true;w=2;wtimeoutMS=2000

mongosh mongodb://username@password@IP/myDB?authSource=admin 

use DATABASE_NAME

myDB> use myDB
already on db myDB
myDB> db
myDB
myDB> 

myDB> use testDB
switched to db testDB
testDB> db
testDB
testDB> show dbs
admin   148.00 KiB
config   48.00 KiB
local    72.00 KiB
myDB     24.00 KiB
testDB> db.collection.insertOne({"name":"name"})
{
  acknowledged: true,
  insertedId: ObjectId('67e2725576db4fd0546b140b')
}
testDB> show dbs
admin   148.00 KiB
config   48.00 KiB
local    72.00 KiB
myDB     24.00 KiB
testDB    8.00 KiB
testDB> 

use testDB
db.createCollection("collectioncreate")
#testDB> db.createCollection("collectioncreate")
#{ ok: 1 }

show dbs

db

use testDB
db.dropDatabase()

testDB> show dbs
admin   148.00 KiB
config   96.00 KiB
local    72.00 KiB
myDB     24.00 KiB
testDB> use myDB
switched to db myDB
myDB> db.dropDatabase()
{ ok: 1, dropped: 'myDB' }
myDB> show dbs
admin   148.00 KiB
config   96.00 KiB
local    72.00 KiB

db.createCollection(name, options)

db.createCollection("myComplexCollection", {
  capped: true,
  size: 10485760,
  max: 5000,
  validator: { $jsonSchema: {
    bsonType: "object",
    required: ["name", "email"],
    properties: {
      name: {
        bsonType: "string",
        description: "必须为字符串且为必填项"
      },
      email: {
        bsonType: "string",
        pattern: "^.+@.+$",
        description: "必须为有效的电子邮件地址"
      }
    }
  }},
  validationLevel: "strict",
  validationAction: "error",
  storageEngine: {
    wiredTiger: { configString: "block_compressor=zstd" }
  },
  collation: { locale: "en", strength: 2 }
});

db.adminCommand({
  renameCollection: "sourceDb.sourceCollection",
  to: "targetDb.targetCollection",
  dropTarget: <boolean>
})

myDB> show dbs
admin   148.00 KiB
config   96.00 KiB
local    72.00 KiB
myDB> show collections

myDB> db.myCollection.find()
[
  {
    _id: ObjectId('67e2794e1bf47fea606b140b'),
    name: 'gaowanlu',
    birth: '2001-12-21'
  }
]
myDB> db.adminCommand({renameCollection:"myDB.myCollection",to:"myDB.gaowanlu",dropTarget:false})
{ ok: 1 }
myDB> show collections
gaowanlu
myDB> 

db.collection.drop()
# 如果成功删除选定集合，则 drop() 方法返回 true，否则返回 false。

myDB> show collections
gaowanlu
myDB> db.gaowanlu.drop()
true
myDB> show collections

myDB> 

db.collection.insertOne(document, options)

db.myCollection.insertOne({
    name: "Alice",
    age: 25,
    city: "New York"
});
{
    "acknowledged": true,
    "insertedId": ObjectId("60c72b2f9b1d8b5a5f8e2b2d")
}

db.collection.insertMany(documents, options)

db.myCollection.insertMany([
    { name: "Bob", age: 30, city: "Los Angeles" },
    { name: "Charlie", age: 35, city: "Chicago" }
]);
{
    "acknowledged": true,
    "insertedIds": [
        ObjectId("60c72b2f9b1d8b5a5f8e2b2e"),
        ObjectId("60c72b2f9b1d8b5a5f8e2b2f")
    ]
}

myDB> db.createCollection("users", {
...   validator: {
...     age: { $gt: 0 }
...   }
... });
{ ok: 1 }
myDB> db.users.insertOne({ name: "John", age: -5 });
Uncaught:
MongoServerError: Document failed validation
Additional information: {
  failingDocumentId: ObjectId('67e27cc51bf47fea606b140c'),
  details: {
    operatorName: '$gt',
    specifiedAs: { age: { '$gt': 0 } },
    reason: 'comparison failed',
    consideredValue: -5
  }
}

mongosh> show dbs
admin   148.00 KiB
config   60.00 KiB
local    72.00 KiB
mongosh> use myDB
switched to db myDB
myDB> show collections

myDB>

db.collection.updateOne(filter, update, options)
# filter：用于查找文档的查询条件。
# update：指定更新操作的文档或更新操作符。

# options：可选参数对象，如 upsert、arrayFilters 等。
upsert
类型: Boolean
默认值: false
作用: 如果没有找到符合条件的文档，是否插入一个新文档。
db.collection.updateMany(
  { name: "example" },
  { $set: { age: 30 } },
  { upsert: true }
);
arrayFilters
类型: Array
作用: 当更新嵌套数组中的元素时，指定过滤条件以匹配数组中的特定元素。
db.collection.updateMany(
  { "items.name": "example" },
  { $set: { "items.$[elem].price": 100 } },
  { arrayFilters: [{ "elem.name": "example" }] }
);
writeConcern
类型: Object
作用: 指定写入操作的确认级别。
db.collection.updateMany(
  { status: "pending" },
  { $set: { status: "completed" } },
  { writeConcern: { w: "majority", wtimeout: 5000 } }
);
collation
类型: Object
作用: 指定字符串比较的规则（如大小写敏感性、语言区域设置等）。
db.collection.updateMany(
  { name: "example" },
  { $set: { status: "active" } },
  { collation: { locale: "en", strength: 2 } }
);
returnDocument
类型: String
在 findOneAndUpdate 中使用，指定返回更新前 ("before") 或更新后 ("after") 的文档。
db.myCollection.findOneAndUpdate(
    { name: "Charlie" },              // 过滤条件
    { $set: { age: 36 } },            // 更新操作
    { returnDocument: "after" }       // 可选参数，返回更新后的文档
);

myDB> db.myCollection.updateOne(
...     { name: "Alice" },                // 过滤条件
...     { $set: { age: 26 } },            // 更新操作
...     { upsert: true }                 // 可选参数 upsert 表示没有就插入
... );
{
  acknowledged: true,
  insertedId: ObjectId('67e656a47b587329a21774fc'),
  matchedCount: 0,
  modifiedCount: 0,
  upsertedCount: 1
}
myDB> db.myCollection.find();
[
  { _id: ObjectId('67e656a47b587329a21774fc'), name: 'Alice', age: 26 }
]
myDB> db.myCollection.updateOne(
...     { name: "Alice" },                // 过滤条件
...     { $set: { age: 79 } },            // 更新操作
...     { upsert: false }                 // 可选参数
... );
{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0
}
myDB> db.myCollection.find();
[
  { _id: ObjectId('67e656a47b587329a21774fc'), name: 'Alice', age: 79 }
]

db.collection.updateMany(filter, update, options)
# filter：用于查找文档的查询条件。
# update：指定更新操作的文档或更新操作符。
# options：可选参数对象，如 upsert、arrayFilters 等。

myDB> db.myCollection.find();
[
  { _id: ObjectId('67e656a47b587329a21774fc'), name: 'Alice', age: 79 }
]
myDB> db.myCollection.updateMany(
...     { age: { $gte: 30 } },             // 过滤条件 age>=30
...     { $set: { status: "active" } },   // 更新操作
...     { upsert: false }                  // 可选参数
... );
{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0
}
myDB> db.myCollection.find();
[
  {
    _id: ObjectId('67e656a47b587329a21774fc'),
    name: 'Alice',
    age: 79,
    status: 'active'
  }
]
myDB> 

db.collection.replaceOne(filter, replacement, options)
# filter：用于查找文档的查询条件。
# replacement：新的文档，将替换旧的文档。
# options：可选参数对象，如 upsert 等。

myDB> db.myCollection.find();
[
  {
    _id: ObjectId('67e656a47b587329a21774fc'),
    name: 'Bob',
    age: 31,
    money: 0
  }
]
myDB> db.myCollection.replaceOne(
...     { _id: ObjectId("67e656a47b587329a21774fc") },                  // 过滤条件
...     { name: "Bob", age: 32}          // 新文档
... );
{
  acknowledged: true,
  insertedId: null,
  matchedCount: 1,
  modifiedCount: 1,
  upsertedCount: 0
}
myDB> db.myCollection.find();
[ { _id: ObjectId('67e656a47b587329a21774fc'), name: 'Bob', age: 32 } ]

db.collection.findOneAndUpdate(filter, update, options)
# filter：用于查找文档的查询条件。
# update：指定更新操作的文档或更新操作符。
# options：可选参数对象，如 projection、sort、upsert、returnDocument 等。

myDB> db.myCollection.find();
[ { _id: ObjectId('67e656a47b587329a21774fc'), name: 'Bob', age: 32 } ]
myDB> db.myCollection.find();
[ { _id: ObjectId('67e656a47b587329a21774fc'), name: 'Bob', age: 32 } ]
myDB> db.myCollection.findOneAndUpdate(
...     { name: "Bob" },              // 过滤条件
...     { $set: { age: 36 } },            // 更新操作
...     { returnDocument: "before" }       // 可选参数，返回更新后的文档
... );
{ _id: ObjectId('67e656a47b587329a21774fc'), name: 'Bob', age: 32 }
myDB>  db.myCollection.find();
[ { _id: ObjectId('67e656a47b587329a21774fc'), name: 'Bob', age: 36 } ]
myDB> 

db.collection.deleteOne(filter, options)
# filter：用于查找要删除的文档的查询条件。
# options（可选）：一个可选参数对象。

myDB>  db.myCollection.find();
[ { _id: ObjectId('67e656a47b587329a21774fc'), name: 'Bob', age: 36 } ]
myDB> db.myCollection.deleteOne({name:"Bob"});
{ acknowledged: true, deletedCount: 1 }
myDB>  db.myCollection.find();

db.collection.deleteMany(filter, options)
# filter：用于查找要删除的文档的查询条件。
# options（可选）：一个可选参数对象。

db.myCollection.updateOne(
    { name: "Alice" },                // 过滤条件
    { $set: { age: 26 } },            // 更新操作
    { upsert: true }                 // 可选参数
);
myDB> db.myCollection.find()
[
  { _id: ObjectId('67e65f237b587329a21774fd'), name: 'Alice', age: 26 }
]
myDB> db.myCollection.deleteMany({name: 'Alice'});
{ acknowledged: true, deletedCount: 1 }
myDB> db.myCollection.find()

myDB> 

db.collection.findOneAndDelete(filter, options)
#filter：用于查找要删除的文档的查询条件。
#options：可选参数对象，如 projection、sort 等。

#findOneAndDelete 返回被删除的文档，如果找不到匹配的文档，则返回 null。

#这些删除方法的 options 参数通常可以包含以下选项：

#writeConcern：指定写操作的确认级别。
#collation：指定比较字符串时使用的排序规则。
#projection（仅适用于 findOneAndDelete）：指定返回的字段。
#sort（仅适用于 findOneAndDelete）：指定排序顺序以确定要删除的文档。

myDB>  db.myCollection.find()
[
  { _id: ObjectId('67e65f697b587329a21774fe'), name: 'Alice', age: 26 }
]
myDB> db.myCollection.findOneAndDelete(
...     { name: "Alice" },
...     { projection: { name: 1, age: 1 , _id: 0} }
... );
{ name: 'Alice', age: 26 }
myDB> db.myCollection.find()

myDB> 

db.collection.find(query, projection)
# query：用于查找文档的查询条件。默认为 {}，即匹配所有文档。
# projection（可选）：指定返回结果中包含或排除的字段。

myDB> db.myCollection.find()
[
  { _id: ObjectId('67e668cd7b587329a21774ff'), name: 'Alice', age: 26 }
]
myDB> db.myCollection.find().pretty();
[
  { _id: ObjectId('67e668cd7b587329a21774ff'), name: 'Alice', age: 26 }
]
myDB> db.myCollection.find({age: {$gt:25}}, {name:1,age:0,_id:1}).pretty();
MongoServerError[Location31254]: Cannot do exclusion on field age in inclusion projection
# 在 projection 中，MongoDB 不允许同时对某些字段使用**包含（1）和排除（0）**操作。
# 具体来说：
# 包含（1）：表示你希望返回某些字段。
# 排除（0）：表示你希望不返回某些字段。
# MongoDB 的规则是：在一个查询的 projection 中，不能同时混用包含和排除字段，但 _id 是一个例外，可以单独排除。

myDB> db.myCollection.find({age: {$gt:25}}, {age:1,_id:1}).pretty();
[ { _id: ObjectId('67e668cd7b587329a21774ff'), age: 26 } ]

db.collection.findOne(query, projection)
# query：用于查找文档的查询条件。默认为 {}，即匹配所有文档。
# projection（可选）：指定返回结果中包含或排除的字段。

db.myCollection.findOne(
    { name: "Alice" },
    { name: 1, age: 1, _id: 0 }
);

# 查找年龄大于 25 的文档:
db.myCollection.find({ age: { $gt: 25 } });

# 查找年龄大于 25 且城市为 "New York" 的文档:
db.myCollection.find({
    $and: [
        { age: { $gt: 25 } },
        { city: "New York" }
    ]
});

# 查找名字以 "A" 开头的文档：
db.myCollection.find({ name: /^A/ });

# 只返回名字和年龄字段：
db.myCollection.find(
    { age: { $gt: 25 } },
    { name: 1, age: 1, _id: 0 }
);

db.myCollection.find().sort({ age: -1 });

# 返回前 10 个文档：
db.myCollection.find().limit(10);
# 跳过前 5 个文档，返回接下来的 10 个文档：
db.myCollection.find().skip(5).limit(10);

# 查找年龄大于 25 且城市为 "New York" 的文档，只返回名字和年龄字段，按年龄降序排序，并返回前 10 个文档。
db.myCollection.find(
    {
        $and: [
            { age: { $gt: 25 } },
            { city: "New York" }
        ]
    },
    { name: 1, age: 1, _id: 0 }
).sort({ age: -1 }).limit(10);

>db.col.find({key1:value1, key2:value2}).pretty()

>db.col.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

>db.col.find({"likes": {$gt:50}, $or: [{"by": "菜鸟教程"},{"title": "MongoDB 教程"}]}).pretty()
{
        "_id" : ObjectId("56063f17ade2f21f36b03133"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "菜鸟教程",
        "url" : "http://www.runoob.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}

{ field: { $eq: value } }

db.collection.find({ age: { $eq: 25 } })

{ field: { $ne: value } }

db.collection.find({ age: { $ne: 25 } })

{ field: { $gt: value } }

db.collection.find({ age: { $gt: 25 } })

{ field: { $gte: value } }

db.collection.find({ age: { $gte: 25 } })

{ field: { $lt: value } }

db.collection.find({ age: { $lt: 25 } })

{ field: { $lte: value } }

db.collection.find({ age: { $lte: 25 } })

{ field: { $in: [value1, value2, ...] } }

db.collection.find({ age: { $in: [20, 25, 30] } })

{ field: { $nin: [value1, value2, ...] } }

db.collection.find({ age: { $nin: [20, 25, 30] } })

{ $and: [ { condition1 }, { condition2 } ] }

db.collection.find({ $and: [{ age: { $gt: 25 } }, { age: { $lt: 35 } }] })

{ $or: [ { condition1 }, { condition2 } ] }

db.collection.find({ $or: [{ age: { $gt: 25 } }, { age: { $lt: 18 } }] })

{ field: { $not: { condition } } }

db.collection.find({ age: { $not: { $gt: 25 } } })

{ $nor: [ { condition1 }, { condition2 } ] }

db.collection.find({ $nor: [{ age: { $gt: 25 } }, { age: { $lt: 18 } }] })

{ field: { $exists: boolean } }

db.collection.find({ age: { $exists: true } })

{ field: { $type: "type" } }

db.collection.find({ age: { $type: "int" } })

db.myCollection.find({ tags: { $all: ["red", "blue"]} });

{ field: { $all: [value1, value2, ...] } }

db.collection.find({ tags: { $all: ["mongodb", "database"] } })

{ field: { $elemMatch: { condition } } }

db.collection.find({ items: { $elemMatch: { quantity: { $gt: 10 } } } })

{ field: { $size: value } }

db.collection.find({ tags: { $size: 3 } })

{ field: { $regex: "pattern" } }

db.collection.find({ name: { $regex: /^John/ } })

{ field: { $near: [longitude, latitude], $maxDistance: distance } }

db.collection.find({ location: { $near: [10, 20], $maxDistance: 1000 } })

{ field: { $geoWithin: { $centerSphere: [[longitude, latitude], radius] } } }

db.collection.find({ location: { $geoWithin: { $centerSphere: [[10, 20], 1] } } })

db.collection.find({ field: { $type: <type> } })
# field：要检查类型的字段。
# type：指定的 BSON 类型，可以是类型的数字代码或类型名称的字符串。

db.myCollection.find({ fieldName: { $type: "string" } })

db.myCollection.find({ fieldName: { $type: 2 } })

db.myCollection.find({ age: { $type: "int" } })
db.myCollection.find({ age: { $type: 16 } })

db.myCollection.find({ isActive: { $type: "bool" } })
db.myCollection.find({ isActive: { $type: 8 } })

db.myCollection.find({ createdAt: { $type: "date" } })
db.myCollection.find({ createdAt: { $type: 9 } })

db.myCollection.find({ value: { $type: ["string", "int"] } })
db.myCollection.find({ value: { $type: [2, 16] } })

db.myCollection.find({
    $and: [
        { details: { $type: "object" } },
        { score: { $type: "double" } }
    ]
});
db.myCollection.find({
    $and: [
        { details: { $type: 3 } },
        { score: { $type: 1 } }
    ]
});

db.collection.find().limit(<limit>)
# <limit>：返回的文档数量。

# 集合 col 中的数据如下：
{ "_id" : ObjectId("56066542ade2f21f36b0313a"), "title" : "PHP 教程", "description" : "PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "php" ], "likes" : 200 }
{ "_id" : ObjectId("56066549ade2f21f36b0313b"), "title" : "Java 教程", "description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "java" ], "likes" : 150 }
{ "_id" : ObjectId("5606654fade2f21f36b0313c"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "mongodb" ], "likes" : 100 }

> db.col.find({},{"title":1,_id:0}).limit(2)
{ "title" : "PHP 教程" }
{ "title" : "Java 教程" }
>

db.collection.find().skip(<skip>)
# <skip>：要跳过的文档数量。

# 跳过前 10 个文档，返回接下来的 10 个文档
db.myCollection.find().skip(10).limit(10);

// 第一页，每页 10 个文档
db.myCollection.find().skip(0).limit(10);

// 第二页，每页 10 个文档
db.myCollection.find().skip(10).limit(10);

// 第三页，每页 10 个文档
db.myCollection.find().skip(20).limit(10);

db.collection.find().sort({ field1: 1, field2: -1 })
# { field1: 1, field2: -1 }：指定要排序的字段及排序顺序。1 表示升序，-1 表示降序。

// 按 age 字段升序排序
db.myCollection.find().sort({ age: 1 });
// 按 createdAt 字段降序排序
db.myCollection.find().sort({ createdAt: -1 });
// 先按 age 字段升序排序，再按 createdAt 字段降序排序
db.myCollection.find().sort({ age: 1, createdAt: -1 });

db.collection.createIndex( keys, options )
# db：数据库的引用。
# collection：集合的名称。
# keys：一个对象，指定了字段名和索引的排序方向（1 表示升序，-1 表示降序）。
# options：一个可选参数，可以包含索引的额外选项。
  # options 参数是一个对象，可以包含多种配置选项，以下是一些常用的选项：
  # unique：如果设置为 true，则创建唯一索引，确保索引字段的值在集合中是唯一的。
  # background：如果设置为 true，则索引创建过程在后台运行，不影响其他数据库操作。
  # name：指定索引的名称，如果不指定，MongoDB 会根据索引的字段自动生成一个名称。
  # sparse：如果设置为 true，创建稀疏索引，只索引那些包含索引字段的文档。
  # expireAfterSeconds：设置索引字段的过期时间，MongoDB 将自动删除过期的文档。
  # v：索引版本，通常不需要手动设置。
  # weights：为文本索引指定权重。

// 创建 age 字段的升序索引
db.myCollection.createIndex({ age: 1 });
// 创建 name 字段的文本索引
db.myCollection.createIndex({ name: "text" });

// 创建唯一索引
db.collection.createIndex( { field: 1 }, { unique: true } )
// 创建后台运行的索引
db.collection.createIndex( { field: 1 }, { background: true } )
// 创建稀疏索引
db.collection.createIndex( { field: 1 }, { sparse: true } )
// 创建文本索引并指定权重
db.collection.createIndex( { field: "text" }, { weights: { field: 10 } } )
// 创建地理空间索引
// 对于存储地理位置数据的字段，可以使用 2dsphere 或 2d 索引类型来创建地理空间索引。
// 2dsphere 索引，适用于球形地理数据
db.collection.createIndex( { location: "2dsphere" } )
// 2d 索引，适用于平面地理数据
db.collection.createIndex( { location: "2d" } )

db.collection.createIndex( { field: "hashed" } )

db.collection.getIndexes()

// 删除指定的索引
db.collection.dropIndex( "indexName" )

// 删除所有索引
db.collection.dropIndexes()

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by_user: 'runoob.com',
   url: 'http://www.runoob.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
},
{
   _id: ObjectId(7df78ad8902d)
   title: 'NoSQL Overview', 
   description: 'No sql database is very fast',
   by_user: 'runoob.com',
   url: 'http://www.runoob.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 10
},
{
   _id: ObjectId(7df78ad8902e)
   title: 'Neo4j Overview', 
   description: 'Neo4j is no sql database',
   by_user: 'Neo4j',
   url: 'http://www.neo4j.com',
   tags: ['neo4j', 'database', 'NoSQL'],
   likes: 750
},

select by_user, count(*) from mycol group by by_user

> db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
{
   "result" : [
      {
         "_id" : "runoob.com",
         "num_tutorial" : 2
      },
      {
         "_id" : "Neo4j",
         "num_tutorial" : 1
      }
   ],
   "ok" : 1
}
>

// $project实例
db.article.aggregate(
    { $project : {
        title : 1 ,
        author : 1 ,
    }}
 );
// 这样的话结果中就只还有_id,tilte和author三个字段了，默认情况下_id字段是被包含的，如果要想不包含_id话可以这样:
db.article.aggregate(
    { $project : {
        _id : 0 ,
        title : 1 ,
        author : 1
    }});

// $match实例
db.articles.aggregate( [
                        { $match : { score : { $gt : 70, $lte : 90 } } },
                        { $group: { _id: null, count: { $sum: 1 } } }
                       ] );
// $match用于获取分数大于70小于或等于90记录，然后将符合条件的记录送到下一阶段$group管道操作符进行处理。

// $skip实例
db.article.aggregate(
    { $skip : 5 });
// 经过$skip管道操作符处理后，前五个文档被"过滤"掉。

mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"

mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0

>rs.add(HOST_NAME:PORT)

>rs.add("mongod1.net:27017")
>

Shard Server 1：27020
Shard Server 2：27021
Shard Server 3：27022
Shard Server 4：27023
Config Server ：27100
Route Process：40000

[root@100 /]# mkdir -p /www/mongoDB/shard/s0
[root@100 /]# mkdir -p /www/mongoDB/shard/s1
[root@100 /]# mkdir -p /www/mongoDB/shard/s2
[root@100 /]# mkdir -p /www/mongoDB/shard/s3
[root@100 /]# mkdir -p /www/mongoDB/shard/log
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27020 --dbpath=/www/mongoDB/shard/s0 --logpath=/www/mongoDB/shard/log/s0.log --logappend --fork
....
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27023 --dbpath=/www/mongoDB/shard/s3 --logpath=/www/mongoDB/shard/log/s3.log --logappend --fork

[root@100 /]# mkdir -p /www/mongoDB/shard/config
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27100 --dbpath=/www/mongoDB/shard/config --logpath=/www/mongoDB/shard/log/config.log --logappend --fork

/usr/local/mongoDB/bin/mongos --port 40000 --configdb localhost:27100 --fork --logpath=/www/mongoDB/shard/log/route.log --chunkSize 500

#  连接到 MongoDB 的 mongos 路由进程
[root@100 shard]# /usr/local/mongoDB/bin/mongo admin --port 40000
MongoDB shell version: 2.0.7
connecting to: 127.0.0.1:40000/admin
# 添加分片
mongos> db.runCommand({ addshard:"localhost:27020" })
{ "shardAdded" : "shard0000", "ok" : 1 }
......
# 添加更多分片
mongos> db.runCommand({ addshard:"localhost:27029" })
{ "shardAdded" : "shard0009", "ok" : 1 }
# 启用数据库的分片功能 启用 test 数据库的分片功能
mongos> db.runCommand({ enablesharding:"test" }) #设置分片存储的数据库
{ "ok" : 1 }
mongos> db.runCommand({ shardcollection: "test.log", key: { id:1,time:1}})
{ "collectionsharded" : "test.log", "ok" : 1 }

db.runCommand({ shardcollection: "test.log", key: { id: 1, time: 1 } })
# 作用：为 test 数据库中的 log 集合设置分片键，并启用分片。
#     shardcollection：MongoDB 的命令，用于为指定集合启用分片。
# "test.log"：指定要分片的集合，格式为 数据库名.集合名。
# key: { id: 1, time: 1 }：
# 指定分片键为 id 和 time，并按升序（1）排序。
# 分片键用于决定数据如何分布到不同的分片中。
# 返回结果：
# "collectionsharded" : "test.log"：表示集合 test.log 已成功启用分片。
# "ok" : 1：表示命令执行成功。

# mkdir /data/log
# mkdir /data/db1
# nohup mongod --port 27020 --dbpath=/data/db1 --logpath=/data/log/rs0-1.log --logappend --fork --shardsvr --replSet=rs0 &

# mkdir /data/db2
# nohup mongod --port 27021 --dbpath=/data/db2 --logpath=/data/log/rs0-2.log --logappend --fork --shardsvr --replSet=rs0 &

mongo localhost:27020 > rs.initiate({_id: 'rs0', members: [{_id: 0, host: 'localhost:27020'}, {_id: 1, host: 'localhost:27021'}]}) 
> rs.isMaster() #查看主从关系

# mkdir /data/db3
# nohup mongod --port 27030 --dbpath=/data/db3 --logpath=/data/log/rs1-1.log --logappend --fork --shardsvr --replSet=rs1 &
# mkdir /data/db4
# nohup mongod --port 27031 --dbpath=/data/db4 --logpath=/data/log/rs1-2.log --logappend --fork --shardsvr --replSet=rs1 &

# mongo localhost:27030
> rs.initiate({_id: 'rs1', members: [{_id: 0, host: 'localhost:27030'}, {_id: 1, host: 'localhost:27031'}]})
> rs.isMaster() #查看主从关系

# mkdir /data/conf1
# nohup mongod --port 27100 --dbpath=/data/conf1 --logpath=/data/log/conf-1.log --logappend --fork --configsvr --replSet=conf &
# mkdir /data/conf2
# nohup mongod --port 27101 --dbpath=/data/conf2 --logpath=/data/log/conf-2.log --logappend --fork --configsvr --replSet=conf &

# mongo localhost:27100
> rs.initiate({_id: 'conf', members: [{_id: 0, host: 'localhost:27100'}, {_id: 1, host: 'localhost:27101'}]})
> rs.isMaster() #查看主从关系

# nohup mongos --port 40000 --configdb conf/localhost:27100,localhost:27101 --fork --logpath=/data/log/route.log --logappend & 

# mongo localhost:40000
> use admin
> db.runCommand({ addshard: 'rs0/localhost:27020,localhost:27021'})
> db.runCommand({ addshard: 'rs1/localhost:27030,localhost:27031'})
> db.runCommand({ enablesharding: 'test'})
> db.runCommand({ shardcollection: 'test.user', key: {name: 1}})

>mongodump -h dbhost -d dbname -o dbdirectory

>mongorestore -h <hostname><:port> -d dbname <path>

root@0b390d7bbbf5:/# mongostat --username admin --password password --authenticationDatabase admin
2025-03-29T12:03:23.964+0000    WARNING: On some systems, a password provided directly using --password may be visible to system status programs such as `ps` that may be invoked by other users. Consider omitting the password to provide it via stdin, or using the --config option to specify a configuration file with the password.
insert query update delete getmore command dirty used flushes vsize  res qrw arw net_in net_out conn                time
    *0    *0     *0     *0       0     1|0  0.0% 0.0%       0 2.56G 101M 0|0 0|0   112b   85.3k   13 Mar 29 12:03:26.064
    *0    *0     *0     *0       0     0|0  0.0% 0.0%       0 2.56G 101M 0|0 0|0   111b   84.3k   13 Mar 29 12:03:27.067
    *0    *0     *0     *0       0     3|0  0.0% 0.0%       0 2.56G 101M 0|0 0|0   299b   85.6k   13 Mar 29 12:03:28.063
    *0    *0     *0     *0       0     0|0  0.0% 0.0%       0 2.56G 101M 0|0 0|0   111b   84.3k   13 Mar 29 12:03:29.066
^C2025-03-29T12:03:29.710+0000  signal 'interrupt' received; forcefully terminating

mongotop [options] [interval]
interval：指定统计信息的刷新间隔（以秒为单位）。默认值为 1 秒。
--host 指定要监控的 MongoDB 实例的主机名（默认是 localhost）。
--port 指定要监控的 MongoDB 实例的端口号（默认是 27017）。
--username 指定用于身份验证的用户名。
--password 指定用于身份验证的密码。
--authenticationDatabase 指定用于身份验证的数据库（默认是 admin）。
--ssl 使用 SSL 连接到 MongoDB 实例。
--rowcount 指定输出的行数，达到行数后停止（默认是无限输出）。

root@0b390d7bbbf5:/# mongotop --username admin --password password --authenticationDatabase admin
2025-03-29T12:07:28.875+0000    WARNING: On some systems, a password provided directly using --password may be visible to system status programs such as `ps` that may be invoked by other users. Consider omitting the password to provide it via stdin, or using the --config option to specify a configuration file with the password.
2025-03-29T12:07:28.896+0000    connected to: mongodb://localhost/

                    ns    total    read    write    2025-03-29T12:07:29Z
        admin.atlascli      0ms     0ms      0ms                        
         admin.sources      0ms     0ms      0ms                        
    admin.system.users      0ms     0ms      0ms                        
  admin.system.version      0ms     0ms      0ms                        
config.system.sessions      0ms     0ms      0ms                        
   config.transactions      0ms     0ms      0ms                        
  local.system.replset      0ms     0ms      0ms                        
   myDB.collectionName      0ms     0ms      0ms                        
     myDB.myCollection      0ms     0ms      0ms                        
     testDB.collection      0ms     0ms      0ms             

npm install mongodb

const { MongoClient } = require('mongodb');

// MongoDB 连接 URI
const uri = "mongodb://localhost:27017";

// 创建 MongoClient 实例
const client = new MongoClient(uri);

async function connectToDatabase() {
    try {
        // 连接到 MongoDB
        await client.connect();
        console.log("Connected to MongoDB!");

        // 选择数据库
        const db = client.db("test"); // 替换为你的数据库名称

        // 选择集合
        const collection = db.collection("users"); // 替换为你的集合名称

        // 示例操作：插入文档
        const result = await collection.insertOne({ name: "Alice", age: 25 });
        console.log("Inserted document:", result.insertedId);

    } catch (error) {
        console.error("Error connecting to MongoDB:", error);
    } finally {
        // 关闭连接
        await client.close();
    }
}

connectToDatabase();

// 插入文档
const result = await collection.insertOne({ name: "Bob", age: 30 });
console.log("Inserted document ID:", result.insertedId);
// 查询文档
// 查询单个文档
const user = await collection.findOne({ name: "Alice" });
console.log("Found user:", user);

// 查询多个文档
const users = await collection.find({ age: { $gte: 25 } }).toArray();
console.log("Found users:", users);
// 更新文档
const updateResult = await collection.updateOne(
    { name: "Alice" }, // 查询条件
    { $set: { age: 26 } } // 更新操作
);
console.log("Updated documents count:", updateResult.modifiedCount);
// 删除文档
const deleteResult = await collection.deleteOne({ name: "Bob" });
console.log("Deleted documents count:", deleteResult.deletedCount);

MONGO_URI=mongodb://localhost:27017

npm install dotenv
require('dotenv').config();
const uri = process.env.MONGO_URI;
const client = new MongoClient(uri);

npm install mongoose

const mongoose = require('mongoose');

// 连接到 MongoDB
mongoose.connect('mongodb://localhost:27017/test', { useNewUrlParser: true, useUnifiedTopology: true })
    .then(() => console.log("Connected to MongoDB!"))
    .catch(err => console.error("Connection error:", err));

// 定义 Schema 和 Model
const userSchema = new mongoose.Schema({
    name: String,
    age: Number
});

const User = mongoose.model('User', userSchema);

// 示例操作
async function run() {
    // 插入文档
    const user = new User({ name: "Charlie", age: 28 });
    await user.save();
    console.log("User saved:", user);

    // 查询文档
    const users = await User.find({ age: { $gte: 25 } });
    console.log("Found users:", users);
}

run();

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "name": "Tom Hanks",
   "contact": "987654321",
   "dob": "01-01-1991"
}

{
   "_id":ObjectId("52ffc4a5d85242602e000000"),
   "building": "22 A, Indiana Apt",
   "pincode": 123456,
   "city": "Los Angeles",
   "state": "California"
} 

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address": [
      {
         "building": "22 A, Indiana Apt",
         "pincode": 123456,
         "city": "Los Angeles",
         "state": "California"
      },
      {
         "building": "170 A, Acropolis Apt",
         "pincode": 456789,
         "city": "Chicago",
         "state": "Illinois"
      }]
} 

>db.users.findOne({"name":"Tom Benzamin"},{"address":1})

{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address_ids": [
      ObjectId("52ffc4a5d85242602e000000"),
      ObjectId("52ffc4a5d85242602e000001")
   ]
}

>var result = db.users.findOne({"name":"Tom Benzamin"},{"address_ids":1})
>var addresses = db.address.find({"_id":{"$in":result["address_ids"]}})

{ $ref: , $id: , $db: }

{
   "_id":ObjectId("53402597d852426020000002"),
   "address": {
   "$ref": "address_home",
   "$id": ObjectId("534009e4d852427820000002"),
   "$db": "runoob"},
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin"
}

>var user = db.users.findOne({"name":"Tom Benzamin"})
>var dbRef = user.address
>db[dbRef.$ref].findOne({"_id":(dbRef.$id)})

{
   "_id" : ObjectId("534009e4d852427820000002"),
   "building" : "22 A, Indiana Apt",
   "pincode" : 123456,
   "city" : "Los Angeles",
   "state" : "California"
}

{
   "_id": ObjectId("53402597d852426020000002"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "gender": "M",
   "name": "Tom Benzamin",
   "user_name": "tombenzamin"
}

>db.users.createIndex({gender:1,user_name:1})

>db.users.find({gender:"M"},{user_name:1,_id:0})

>db.users.find({gender:"M"},{user_name:1})

{
   "_id": ObjectId("53402597d852426020000002"),
   "tags": ["tag1", "tag2", "tag3"]
}

db.users.find({ tags: "tag1" }, { tags: 1, _id: 0 })

{
   "_id": ObjectId("53402597d852426020000002"),
   "address": { city: "New York", zip: "10001" }
}

db.users.find({ "address.city": "New York" }, { "address.city": 1, _id: 0 })

>db.users.ensureIndex({gender:1,user_name:1})

>db.users.find({gender:"M"},{user_name:1,_id:0}).explain()
{
   "cursor" : "BtreeCursor gender_1_user_name_1",
   "isMultiKey" : false,
   "n" : 1,
   "nscannedObjects" : 0,
   "nscanned" : 1,
   "nscannedObjectsAllPlans" : 0,
   "nscannedAllPlans" : 1,
   "scanAndOrder" : false,
   "indexOnly" : true,
   "nYields" : 0,
   "nChunkSkips" : 0,
   "millis" : 0,
   "indexBounds" : {
      "gender" : [
         [
            "M",
            "M"
         ]
      ],
      "user_name" : [
         [
            {
               "$minElement" : 1
            },
            {
               "$maxElement" : 1
            }
         ]
      ]
   }
}

>db.users.find({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1})

>db.users.find({gender:"M"},{user_name:1,_id:0}).hint({gender:1,user_name:1}).explain()

book = {
          _id: 123456789,
          title: "MongoDB: The Definitive Guide",
          author: [ "Kristina Chodorow", "Mike Dirolf" ],
          published_date: ISODate("2010-09-24"),
          pages: 216,
          language: "English",
          publisher_id: "oreilly",
          available: 3,
          checkout: [ { by: "joe", date: ISODate("2012-10-15") } ]
        }

db.books.findAndModify ( {
   query: {
            _id: 123456789,
            available: { $gt: 0 }
          },
   update: {
             $inc: { available: -1 },
             $push: { checkout: { by: "abc", date: new Date() } }
           }
} )