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;
}
}
这种修改可以把原来嵌套查询达到12秒的处理时间降低到0.3秒
第二:尽量避免嵌入不断增加的数据;
MongoDB存储数据的机制决定了对数组不断追加数据是很低效的。在正常使用中数组和对象大小应该相对固定。
第三:预填充数据;
比如统计每个小时的访问量,先建一个24个0的数组。
第四:尽可能预先分配空间;
知道文档开始比较小,后面会变为确定的大小的,可以先存个确定大小的填充字段,再删除(
u
n
s
e
t
)
这个字段。如果存储文档时便为其分配将来所需的空间,之后便不再需要移动它。第五:文档要自给自足;
M
o
n
g
o
D
B
只存取数据,不做计算。计算尽量在客户端(包括调用
M
o
n
g
o
D
B
的后台服务器)完成。第六:避免使用
unset)这个字段。如果存储文档时便为其分配将来所需的空间,之后便不再需要移动它。 第五:文档要自给自足; MongoDB只存取数据,不做计算。计算尽量在客户端(包括调用MongoDB的后台服务器)完成。 第六:避免使用
unset)这个字段。如果存储文档时便为其分配将来所需的空间,之后便不再需要移动它。第五:文档要自给自足;MongoDB只存取数据,不做计算。计算尽量在客户端(包括调用MongoDB的后台服务器)完成。第六:避免使用where;
第七:编写代码处理数据完整性问题;
在后台执行一些检查和保护数据的脚本,能解除很多后顾之忧,避免出现脏数据。
第八:使用正确的类型;
数据类型影响数据的查询方式、数据存放顺序、占用多少空间。数字,日期,字符串。
第九:用简单唯一的id替换掉_id。
节省空间,注意这个唯一id要是唯一的。原来_id具有递增不重复的作用,代替它的id也有具有该功能来避免出现脏数据。
第十:在经常查询字段上创建索引。
在大数据的情况下,在索引上查找可以提交10倍以上甚至1000倍的速度。
实际测试,不在索引上查找用时12秒左右。建立索引,在索引上查找速度提高只耗时1.1秒左右。当然索引也是一把双刃剑,在一个表上创建索引过多反而降低查询速度。
注意:所有具有包含关系。