提高MongoDB效率九大优化方式

MongoDB九大优化方式：
第一：单次批量查询比循环逐条查询更快；
循环查询是开发者最常犯的错误写法。循环嵌套查询写代码快，逻辑简单，最耗时。在小批量数据处理时间一般远小于数据库查询时间。所以尽量避免增加查询次数，能把多次查询合并成单次批量查询尽量查询。解决办法：先预处理把查询字段合并成一个数组，然后数组中的同类项，接着用批量查询（包括管道操作），转成map，最后用map的get方法查找数据。

let list = await VRRecord.find({
            type: '航拍',
            status: {
                $in: ['', null, 'FINISH']
            }
        }, '-_id -estate_id -views_num').sort({
            create_time: -1
        }).lean().exec();
        // let time1 =  new Date().getTime();
        // logger.debug('time1-time0:', time1-time0, 'list.length:', list.length);
        // 使用map和concat来遍历list，并提取每个元素的estates数组
        let newList = [].concat(...list.map(item => {
            // 确保estates是一个数组
            return Array.isArray(item.estates) ? item.estates : [];
        }));
        // 使用Set来去除重复的
        newList = Array.from(new Set(newList));
        // logger.debug('newList:', newList);
        let subUserMap = new Map();
        if(newList.length > 0){
            let realEstateList = await EstateModel.find({
                id: {
                    $in: newList
                }
            },'-_id id real_estate_name').lean().exec();
            subUserMap = new Map(realEstateList.map(item => [item.id, item]));
        }
        // logger.debug('subUserMap:', subUserMap);
        let newList2 = [].concat(...list.map(item => {
            // 确保lands是一个数组
            return Array.isArray(item.lands) ? item.lands : [];
        }));
        // 使用Set来去除重复的
        newList2 = Array.from(new Set(newList2));
        // logger.debug('newList:', newList);
        let subUserMap2 = new Map();
        if(newList2.length > 0){
            let matchLands = await LandModel.find({
                id: {
                    $in: newList2
                }
            },'-_id id name').lean().exec();
            subUserMap2 = new Map(matchLands.map(item => [item.id, item]));
        }

        let nameMap = {};
        for (let i=0; i<list.length; i++) {
            list[i].hasMarker = false;
            if (list[i].markers) {
                for (let key in list[i].markers) {
                    if (list[i].markers[key].length) {
                        list[i].hasMarker = true;
                        break;
                    }
                }
            }
            delete list[i].markers;
            let matchEstates = [];
            if (list[i].estates) {
                for (let k=0; k<list[i].estates.length; k++) {
                    let id = list[i].estates[k];
                    if (!nameMap[id]) {
                        let realEstate = subUserMap.get(id);
                        // await EstateModel.findOne({
                        //     id: id
                        // },'-_id id real_estate_name').lean().exec();
                        nameMap[id] = realEstate;
                    }
                    if (nameMap[id]) {
                        matchEstates.push(nameMap[id]);
                    }
                }
            }
            list[i].real_estate_name = matchEstates.map(x => x.real_estate_name).join(',');
            list[i].matchEstates = matchEstates;

            if (list[i].lands) {
                let newLands = [];
                list[i].lands.forEach(land =>{
                    if(land){
                        let item = subUserMap2.get(land);
                        if(item){
                            newLands.push(item);
                        }
                    }
                });
                // let matchLands = await LandModel.find({
                //     id: {$in: list[i].lands}
                // }, 'id name -_id');
                list[i].matchLands = newLands;//matchLands;
            }

        }
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

这种修改可以把原来嵌套查询达到12秒的处理时间降低到0.3秒

第二：尽量避免嵌入不断增加的数据；
MongoDB存储数据的机制决定了对数组不断追加数据是很低效的。在正常使用中数组和对象大小应该相对固定。
第三：预填充数据；
比如统计每个小时的访问量，先建一个24个0的数组。
第四：尽可能预先分配空间；
知道文档开始比较小，后面会变为确定的大小的，可以先存个确定大小的填充字段，再删除($unset)这个字段。如果存储文档时便为其分配将来所需的空间，之后便不再需要移动它。第五：文档要自给自足；MongoDB只存取数据，不做计算。计算尽量在客户端（包括调用MongoDB的后台服务器）完成。第六：避免使用$where；
第七：编写代码处理数据完整性问题；
在后台执行一些检查和保护数据的脚本，能解除很多后顾之忧，避免出现脏数据。
第八：使用正确的类型；
数据类型影响数据的查询方式、数据存放顺序、占用多少空间。数字，日期，字符串。
第九：用简单唯一的id替换掉_id。
节省空间，注意这个唯一id要是唯一的。原来_id具有递增不重复的作用，代替它的id也有具有该功能来避免出现脏数据。