Skip to content

文档

插入文档

  • 单条文档 

    1
    > db.集合名称.insert(<DOCUMENT>)

    1
    > db.users.insert({ "name": "boii", "age": 18 })

  • 多条文档 

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    > db.COLLECTION.insertMany(
    [ <DOCUMENT1>, <DOCUMENT2>, ... ],
    {
        writeConcern: < 0 | 1 >, # 写入策略，默认1要求确认写操作，0不要求
        ordered: <bool>          # 指定是否按顺序写入，默认true，按顺序写入
    }
)

或
> db.COLLECTION.insert(
    [ <DOCUMENT1>, <DOCUMENT2>, ... ],
)

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
    > db.users.insertMany(
    [
        { "name": "boii", "age": 18 },
        { "name": "eva", "age": 19 },
    ]
)

# ======

{
    "acknowledged" : true,
    "insertedIds" : [
            ObjectId("629c936d7afcd160f88f852d"),
            ObjectId("629c936d7afcd160f88f852e")
    ]
}

  • 脚本方式 

    1
2
3
4
5
6
7
    > for (let i = 0; i < 100; i++) {
    db.users.insert({ '_id': i, 'name': 'boii', 'age': 18 })
}

#======

WriteResult({ "nInserted" : 1 })

删除文档

1
2
3
4
5
6
7
> db.COLLECTION.remove(
    <query>,    # 筛选条件，不带条件时须写个空对象，表示删除所有
    {
        justOne: <bool>,            # 默认false，为 true 时只删除一条文档
        writeConcern: <document>    # 抛出异常的级别
    }
)

删除满足条件的文档： 

1
2
3
4
5
6
7
> db.users.remove(
    { 'name': 'boii' }
)

# ======

WriteResult({ "nRemoved" : 100 })
删除所有： 
1
> db.users.remove({})

更新文档

1
2
3
4
5
6
7
8
9
> db.COLLECTION.update(
    <query>,        # 筛选条件，不带条件时须写个空对象
    <update data>,  # 更新的内容，相当于 sql 中 set 后面部分
    {
        upsert: <boolean>,        # 如果文档存在则更新，不存在则插入。默认 false 不插入
        multi: <boolean>,         # true更新所有符合条件的文档，false只更新一条。默认false
        writeConcern: <document>  # 抛出异常的级别
    }
)

1
2
3
4
> db.users.update(
    { name: 19 },
    { birth: '2000-01-01' }
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# 将 name 为 boii 的文档删除，然后插入后面的记录
> db.users.update({name: "boii"}, {name: 'eva', bir: new data()})

# 保留原来的记录，只更新 name 字段，但只更新一条数据
> db.users.update({name: "xiaohei"}, {$set: {name: "alice"}})

# 保留原来的记录，只更新 name 字段，但更新所有符合条件的
> db.users.update({name: "xiaohei"}, {$set: {name: "alice"}}, {multi: true})

# 保留原来的记录，只更新 name 字段，更新所有符合条件的，没有条件符合时插入
> db.users.update({name: "xiaohei"}, {$set: {name: "alice"}}, {multi: true, upsert: true})

查询文档

1
2
3
4
> db.COLLECTION.find(
    <query>,        # 筛选条件
    <projection>    # 投影
).pretty()  # 格式化输出
操作 格式 范例 对应 SQL
等于 {key: value} db.col.find({name: 'boii'}) where name = 'boii'
小于 {key: {$lt: value}} db.col.find({age: {$lt: 50}}) where age < 50
小于等于 {key: {$lte: value}} db.col.find({age: {$lte: 50}}) where age <= 50
大于 {key: {$gt: value}} db.col.find({age: {$gt: 50}}) where age > 50
大于等于 {key: {$gte: value}} db.col.find({age: {$gte: 50}}) where age >= 50
不等于 {key: {$ne: value}} db.col.find({age: {$ne: 50}}) where age != 50

AND

1
> db.COLLECTION.find({key1: value1, key2: value2, ...})
对应 SQL 的 WHERE key1 = value1 AND key2 = value2

1
2
3
> db.users.find(
    { name: 'boii', age: 18 }
)

OR

1
2
3
4
5
6
7
> db.COLLECTION.find(
    {
        $or: [
            {key1: value1}, {key2: value2},...
        ]
    }
)
对应 SQL 的 WHERE key1 = value1 OR key2 = value2

1
2
3
4
5
6
7
> db.users.find({
    $or: [
        {name: 'boii'},
        {age: 18},
        ...
    ]
})

AND + OR

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
> db.COLLECTION.find(
    {
        key1: value1,
        ...
        $or: [
            {key2: value2},
            {key3: value3}，
            ...
        ]
    }
)
对应 SQL 的 WHERE key1 = value1 AND ( key2 = value2 OR key3 = value3 )

1
2
3
4
5
6
7
8
9
> db.users.find(
    {
        age: {$gt: 50},
        $or: [
            {name: 'boii'},
            {name: 'eva'}
        ]
    }
)

模糊查询

1
> db.COLLECTION.find({ key: regex })
正则表达式以 / 开头和结尾，对应 SQL 中的 WHERE key LIKE '%regex%'

1
> db.users.find({ name: /bo/ })
相当于SQL的 WHERE name LIKE '%bo%'

排序

1
> db.COLLECTION.find(...).sort({ key: 1, key: -1 })
1 升序，-1 降序

对应 SQL 的 ORDER BY key ASC、ORDER BY key DESC

1
> db.users.find().sort({ age: 1 })

分页

1
> db.COLLECTION.find().skip(start).limit(rows)
对应 SQL 的 LIMIT start, rows

1
> db.users.find().skip(5).limit(10)

总条数

1
2
> db.COLLECTION.count()
> db.COLLECTION.find({条件}).count()
对应 SQL 的 SELECT count(1) FROM ...

1
2
3
4
> db.users.count()
10
> db.users.find({name: 'boii'}).count()
5

去重

1
> db.COLLECTION.distince('字段')
对应 SQL 的 SELECT DISTINCT 字段 FROM ...

指定返回字段

1
> db.COLLECTION.find({条件}, {key: 1, key: 1, ...})
1 返回，0 不返回。0 和 1 不能同时使用 
1
2
3
4
5
6
7
> db.users.find({}, { name: 1})
{ "_id" : 0, "name" : "boii", "age" : 18 }
{ "_id" : 1, "name" : "boii", "age" : 18 }
{ "_id" : 2, "name" : "boii", "age" : 18 }
{ "_id" : 3, "name" : "boii", "age" : 18 }
{ "_id" : 4, "name" : "boii", "age" : 18 }
...