MongoDB基础语法

发表于 分类于 阅读次数： 本文字数： 973 阅读时长 ≈ 4 分钟

MongoDB 基础语法

数据库

选中数据库，不存在则创建
1
use mydb;
删除数据库
1
db.dropDatabase();
查看当前数据库
1
db;
查看全部数据库
1
show dbs;
查看当前数据库下全部集合
1
show collections;
查看版本
1
db.version();

集合

创建集合
1
db.createCollection("mycol2");
删除集合
1
db.myco2.drop();
删除集合下全部文档
1
db.mycol2.remove();
查询集合下全部文档
1
db.mycol2.find();

索引

创建索引

（1 升序 -1 降序）（name 索引名称，unique 唯一，background 后台创建）

1
2
3
4
5
6
7
8
db.mycol2.createIndex({
    "name": 1,
    "age": - 1
}, {
    "name": "uk_name_age",
    "unique": 1,
    "background": true
});
删除全部索引
1
db.mycol2.dropIndexes()
删除指定索引
1
db.mycol2.dropIndex("uk_name_age")
查看全部索引
1
db.mycol2.getIndexes()

文档

添加（如果集合不存在则创建集合）

insert 已不再建议使用，使用 insertOne 或 insertMany
区别：
https://stackoverflow.com/questions/36792649/whats-the-difference-between-insert-insertone-and-insertmany-method
insert 单个插入返回 WriteResult 对象，批量插入返回一个 BulkWriteResult 对象，insertOne 和 insertMany 返回插入对象的 ObjectId
insert 命令在成功和错误情况下都返回一个文档，insertOne 和 insertMany 命令会引发异常

添加单条文档
1
2
3
4
5
db.mycol2.insertOne({
    "name": "chen",
    "age": 18,
    "email": "chen@163.com"
});
添加多条文档
1
2
3
4
5
6
7
8
9
10
db.mycol2.insertMany([
    {
        "name": "张三",
        "age": 18
    },
    {
        "name": "李四",
        "age": 20
    }
]);
删除
指定条件删除文档（remove，deleteOne，deleteMany）
1
2
3
db.mycol2.deleteMany({
    "name": "张三"
});
查询
in，and，or使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
db.mycol2.find(
    {
        "isDel": 0,
        "role": {
            $in: ['管理员1号', '管理员2号']
        },
        "$or": [
            {
                "name": "陈1"
            },
            {
                "age": {
                    "$gte": 20
                }
            }
        ]
    }
)
比较（gt >，lt <，gte >=，lte <=，ne !=）
1
2
3
4
5
6
7
db.mycol2.find({
    "age": {
        "$gt": 15,
        "$lt": 30,
        "$ne": 20
    }
})
limit 和 skip 使用
1
db.mycol2.find().limit(2).skip(1);
排序（1 升序，-1 降序）
1
2
3
db.mycol2.find().sort({
    "age": - 1
})
统计数量
1
db.mycol2.find().count()
正则
1
2
3
db.mycol2.find({
    "name": /陈/
});
模糊查询（左、右、全）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
db.mycol2.find({
    "name": {
        "$regex": "^chen.*$"
    }
})

db.mycol2.find({
    "name": {
        "$regex": "^.*kaixin$"
    }
})

db.mycol2.find({
    "name": {
        "$regex": "^.*chenkaixin.*$"
    }
})
查询单个字段并去重
1
db.mycol2.distinct("name");
时间
1
2
3
4
5
6
db.mycol2.find({
    "createTime": {
        $gt: new Date("2020-02-03T06:24:40.110Z"),
        $lt: new Date("2020-02-05T06:14:40.089Z")
    }
});
指定字段（1 查询，0 排除）
1
2
3
4
db.mycol2.find({}, {
    "name": 1,
    "_id": 0
});
更新

带_id是添加，不带_id则更新

1
2
3
4
5
db.mycol2.save({
    "_id": ObjectId("613a1c32864100008c006de9"),
    "name": "麻子",
    "age": 3
});
根据条件更新一条
1
2
3
4
5
6
7
8
9
10
db.mycol2.updateOne(
    {
        "age": 18
    },
    {
        $set: {
            "name": "18真好"
        }
    }
);
更新多条
1
2
3
4
5
6
7
8
9
10
db.mycol2.updateMany({
    "age": 30
}, {
    $set: {
        "name": '30真好啊222',
        "age": 30
    }
}, {
    upsert: true
});
嵌套字段
1
2
3
4
5
6
7
db.inventory.insertMany( [
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }
]);
精确匹配
1
2
3
4
5
6
7
db.inventory.find({
    size: {
        h: 14,
        w: 21,
        uom: "cm"
    }
})
相等匹配
1
2
3
db.inventory.find({
    "size.uom": "in"
})
指定匹配
1
2
3
4
5
6
7
db.inventory.find({
    "size.h": {
        $lt: 15
    },
    "size.uom": "in",
    status: "D"
})
数组
1
2
3
4
5
6
7
db.inventory.insertMany([
   { item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] },
   { item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] },
   { item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] },
   { item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] },
   { item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }
]);
指定顺序和大小查询
1
2
3
db.inventory.find({
    tags: ["red", "blank"]
})
不指定
1
2
3
4
5
db.inventory.find({
    tags: {
        $all: ["red", "blank"]
    }
})
包含指定元素
1
2
3
db.inventory.find({
    tags: "red"
});
组合满足条件
1
2
3
4
5
6
db.inventory.find({
    dim_cm: {
        $gt: 15,
        $lt: 20
    }
});
满足全部条件
1
2
3
4
5
6
7
8
db.inventory.find({
    dim_cm: {
        $elemMatch: {
            $gt: 22,
            $lt: 30
        }
    }
});
使用长度查询
1
2
3
4
5
db.inventory.find({
    "tags": {
        $size: 3
    }
});
数组文档
1
2
3
4
5
6
7
db.inventory.insertMany( [
   { item: "journal", instock: [ { warehouse: "A", qty: 5 }, { warehouse: "C", qty: 15 } ] },
   { item: "notebook", instock: [ { warehouse: "C", qty: 5 } ] },
   { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 15 } ] },
   { item: "planner", instock: [ { warehouse: "A", qty: 40 }, { warehouse: "B", qty: 5 } ] },
   { item: "postcard", instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }
]);
对字段进行查询
1
2
3
4
5
db.inventory.find({
    'instock.qty': {
        $lte: 20
    }
})
使用数组的索引查询
1
2
3
4
5
db.inventory.find({
    'instock.0.qty': {
        $lte: 20
    }
})
组合满足条件
1
2
3
4
5
6
db.inventory.find({
    "instock.qty": {
        $gt: 10,
        $lte: 20
    }
})
满足全部条件
1
2
3
4
5
6
7
8
9
10
db.inventory.find({
    "instock": {
        $elemMatch: {
            qty: {
                $gt: 10,
                $lte: 20
            }
        }
    }
})

聚合

常用操作
sql mongo
select $project
where $match
join $lookup
group by $group
having $match
order by $sort
limit $limit
sum() $sum
count() $sum
age() $age
min() $min
max() $max
示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
db.mycol2.aggregate([
    {
        $group: {
            _id: "$name",
            user_count: {
                $sum: 1
            }
        }
    },
    {
        $match: {
            "user_count": {
                $gt: 10
            }
        }
    },
    {
        $skip: 3
    },
    {
        $limit: 10
    },
    {
        $sort: {
            user_count: - 1
        }
    }
])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
db.mycol2.aggregate([
    {
        $match: {
            isDel: 0
        }
    },
    {
        $group: {
            _id: "$name",
            age_sum: {
                $sum: "$age"
            }
        }
    }
])