MongoDB进阶

于 2025-05-15 10:41:34 发布
阅读量739 收藏 10
点赞数 19
文章标签： mongodb 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yw2490614330/article/details/147976978
版权

内容

1.MongoDB聚合操作
2.MongoDB聚合优化，
3.MongoDB索引原理及实战

MongoDB聚合框架是一个计算框架作用在一个或几个集合对集合中的数据进行一系列运算
将这些数据转化为期望的形式

1.MongoDB聚合操作
2.MongoDB聚合优化，
3.MongoDB索引原理及实战
MongoDB聚合框架是一个计算框架作用在一个或几个集合对集合中的数据进行一系列运算
将这些数据转化为期望的形式
如： 现在有一组数据
1 db.orders.insertMany(
2 [
3 {
4 zip:"000001",
5 phone:"13101010101",
6 name:"LiuBei",
7 status:"created",
8 shippingFee:10,
9 orderLines:[
10 {product:"Huawei Meta30 Pro",sku:"2002",qty:100,price:6000,cost:5599},
11 {product:"Huawei Meta40 Pro",sku:"2003",qty:10,price:7000,cost:6599},
12 {product:"Huawei Meta40 5G",sku:"2004",qty:80,price:4000,cost:3700}
13 ]
14 },
15
16 {
17 zip:"000001",
18 phone:"13101010101",
19 name:"LiuBei",
20 status:"created",
21 shippingFee:10,
22 orderLines:[
23 {product:"Huawei Meta30 Pro",sku:"2002",qty:100,price:6000,cost:5599},
24 {product:"Huawei Meta40 Pro",sku:"2003",qty:10,price:7000,cost:6599},
25 {product:"Huawei Meta40 5G",sku:"2004",qty:80,price:4000,cost:3700}
26 ]
27 },
28
29 {
30 zip:"000001",
31 phone:"13101010101",
32 name:"LiuBei",
33 status:"created",
34 shippingFee:10,
35 orderLines:[
36 {product:"Huawei Meta30 Pro",sku:"2002",qty:100,price:6000,cost:5599},
37 {product:"Huawei Meta40 Pro",sku:"2003",qty:10,price:7000,cost:6599},
38 {product:"Huawei Meta40 5G",sku:"2004",qty:80,price:4000,cost:3700}
39 ]
40 }]
41 );
原价总额，订单总额
添加两个字段，值为每个订单的原价总价和 订单总额
1 db.orders.aggregate([{$addFields: {
2 totalPrice:{ $sum: "$orderLines.price"},
3 totalCost: { $sum: "$orderLines.cost"},
4 }}]);
1 按 totalPrice 进行排序
2 [{
3 $addFields: {
4 totalPrice: {
5 $sum: "$orderLines.price"
6 },
7 totalCost: {
8 $sum: "$orderLines.cost"
9 },
10 }
11 }
12 , // stage 1
13
14 {
15 $sort: {
16 totalPrice: ‐1
17 }
18 } // stage 2
19 ]
20

第一个阶段：

针对整个集合添加两个字段：
totalPrice: 订单原价总额
totalCost：订单实际总额
并将结果传到第二个阶段

第二个阶段：

按订单总价进行排序

聚合表达式

获取字段信息
$<field> ： 用 $ 指示字段路径
$<field>.<sub field> ： 使用 $ 和 . 来指示内嵌文档的路径
常量表达式
$literal :<value> ： 指示常量 <value>
系统变量表达式
$$<variable> 使用 $$ 指示系统变量
$$CURRENT 指示管道中当前操作的文档
聚合管道阶段
$project 对输入文档进行再次投影
$match 对输入文档进行筛选
$limit 筛选出管道内前 N 篇文档
$skip 跳过管道内前N篇文档
$unwind 展开输入文档中的数组字段
$sort 对输入文档进行排序
$lookup 对输入文档进行查询操作
$group 对输入文档进行分组
$out 对管道中的文档输出

准备数据
1 db.userInfo.insertMany(
2 [
3 {nickName:"zhangsan",age:18},
4 {nickName:"lisi",age:20}]
5 );
聚合管道操作
$project ： 投影操作， 将原始字段投影成指定名称， 如将 集合中的 nickName 投影成 name
1 db.userInfo.aggregate({$project:{ name:"$nickName"}});
$project 可以灵活控制输出文档的格式，也可以剔除不需要的字段
1 db.userInfo.aggregate({$project:{ name:"$nickName",_id:0,age:1}});
$match
$match 进行文档筛选
1 db.userInfo.aggregate({$match:{ nickName:"lisi"}});
筛选管道操作和其他管道操作配合时候时，尽量放到开始阶段，这样可以减少后续管道操作符要操作的文
档数，提升效率
将筛选 和 投影结合使用
1
2 db.userInfo.aggregate(
3 [
4 { $match: { nickName: "lisi"}},
5 { $project: { _id:0, name: "$nickName", age:1}}
6 ]
7 );
1 db.userInfo.aggregate(
2 [
3 { $match:
4 { $and:
5 [ { age: { $gte:20}},
6 { nickName:{ $eq:"lisi"}}
7 ]
8 }
9 },
10 {
11 $project: { _id:0, name: "$nickName", age:1}
12 }
13 ]
14 );
$limit
$skip
1 db.userInfo.aggregate({$limit:1});
2 db.userInfo.aggregate({$skip:1});
$unwind
将数组打平
构造数据
1 db.userInfo.insertOne(
2 { "nickName" : "xixi",
3 "age" : 35,
4 "tags" : ["80","IT","BeiJing"]
5 }
6 );
1 db.userInfo.aggregate(
2 { $unwind:{path:"$tags"}}
3 );
includeArrayIndex: 加上数组元素的索引值， 赋值给后面指定的字段
1 db.userInfo.aggregate(
2 {$unwind: {path: "$tags",includeArrayIndex:"arrIndex"}}
3 );
preserveNullAndEmptyArrays:true
1 db.userInfo.aggregate(
2 { $unwind:
3 {
4 path: "$tags",
5 includeArrayIndex:"arrIndex",
6 preserveNullAndEmptyArrays:true}
7 }
8 );
展开时保留空数组，或者不存在数组字段的文档
$sort 对文档进行排序： 1 正序， -1 倒序
1 db.userInfo.aggregate({$sort:{age:‐1}});
$lookup
使用单一字段值进行查询
1 $lookup:{
2 from: 需要关联的文档,
3 localField: 本地字段，
4 foreignField: 外部文档关联字段，
5 as 作为新的字段，添加到文档中
6 }
1 db.account.insertMany(
2 [
3 {_id:1,name:"zhangsan",age:19},
4 {_id:2,name:"lisi",age:20}
5 ]
6 );
1 db.accountDetail.insertMany(
2 [
3 {aid:1,address:["address1","address2"]}
4 ]
5 );
1 db.accountDetail.aggregate(
2 {
3 $lookup:
4 {
5 from:"account",
6 localField:"aid",
7 foreignField:"_id",
8 as: "field1"
9 }
10 }
11 );
$group
1 $group:{
2 _id: 对哪个字段进行分组，
3 field1:{ accumulator1: expression1 }
4 }
group 聚合操作默认不会对输出结果进行排序
对于group ，聚合操作主要有以下几种
$addToSet ：将分组中的元素添加到一个数组中，并且自动去重
$avg 返回分组中的平均值， 非数值直接忽略
$first 返回分组中的第一个元素
$last 返回分组中的最后一个元素
$max 返回分组中的最大元素
$min 回分组中的最小元素
$push 创建新的数组，将值添加进去
$sum 求分组数值元素和
构造一组数据
1 db.sales.insertMany(
2 [
3 { "_id" : 1, "item" : "abc", "price" : 10, "quantity" : 2, "date" : ISODate("2014‐01‐01
T08:00:00Z") },
4 { "_id" : 2, "item" : "jkl", "price" : 20, "quantity" : 1, "date" : ISODate("2014‐02‐03
T09:00:00Z") },
5 { "_id" : 3, "item" : "xyz", "price" : 5, "quantity" : 5, "date" : ISODate("2014‐02‐03T
09:05:00Z") },
6 { "_id" : 4, "item" : "abc", "price" : 10, "quantity" : 10, "date" : ISODate("2014‐02‐1
5T08:00:00Z") },
7 { "_id" : 5, "item" : "xyz", "price" : 5, "quantity" : 10, "date" : ISODate("2014‐02‐15
T09:12:00Z") },
8 { "_id" : 6, "item" : "xyz", "price" : 5, "quantity" : 10, "date" : ISODate("2014‐02‐15
T09:12:00Z") }
9 ]
10 );
$addToSet
查看每天，卖出哪几种商品项目
按每天分组， 将商品加入到去重数组中
1 db.sales.aggregate(
2 [
3 {
4 $group:
5 {
6 _id: { day: { $dayOfYear: "$date"}, year: { $year: "$date" } },
7 itemsSold: { $addToSet: "$item" }
8 }
9 }
10 ]
11 )
$avg: 求数值的平均值
1 db.sales.aggregate(
2 [
3 {
4 $group:
5 {
6 _id: "$item",
7 avgAmount: { $avg: { $multiply: [ "$price", "$quantity" ] } },
8 avgQuantity: { $avg: "$quantity" }
9 }
10 }
11 ]
12 )
$push
创建新的数组，存储，每个分组中元素的信息
1 db.sales.aggregate(
2 [
3 {
4 $group:
5 {
6 _id: { day: { $dayOfYear: "$date"}, year: { $year: "$date" } },
7 itemsSold: { $push: { item: "$item", quantity: "$quantity" } }
8 }
9 }
10 ]
11 )
12
group 阶段有 100m内存的使用限制， 默认情况下，如果超过这个限制会直接返回 error，
可以通过设置 allowDiskUse 为 true 来避免异常， allowDiskUse 为 true 将利用临时文件来辅助实现
group操作。
$out
将聚合结果写入另一个文档
1 db.sales.aggregate(
2 [
3 {
4 $group:
5 {
6 _id: { day: { $dayOfYear: "$date"}, year: { $year: "$date" } },
7 itemsSold: { $push: { item: "$item", quantity: "$quantity" } }
8 }
9 },
10 { $out:"output"}
11 ]
12 )

管道优化

1. 投影优化
聚合管道可以确定它是否仅需要文档中的字段的子集来获得结果。如果是这样，管道将只使用那些必需的
字段，减少通过管道的数据量。
2. 管道符号执行顺序优化
对于包含投影阶段($project或$unset或$addFields或$set)后跟$match阶段的聚合管道，MongoDB 将
$match阶段中不需要在投影阶段计算的值的任何过滤器移动到投影前的新$match阶段
3. $sort + $match
如果序列中带有$sort后跟$match，则$match会移动到$sort之前，以最大程度的减少要排序的对象的数
量
4. $project/ $unset + $skip序列优化
当有一个$project或$unset之后跟有$skip序列时，$skip 会移至$project之前。
5.$limit+ $limit合并
当$limit紧接着另一个时 $limit，两个阶段可以合并为一个阶段 $limit，其中限制量为两个初始限制量中的
较小者。
6. skip+ $skip 合并
当$skip紧跟另一个$skip，这两个阶段可合并成一个单一的$skip，其中跳过量为总和的两个初始跳过量。
7. $match+ $match合并
当一个$match紧随另一个紧随其后时 $match，这两个阶段可以合并为一个单独 $match的条件 $and

1 { $match: { year: 2014 } },
2 { $match: { status: "A" } }
优化后
1 { $match: { $and: [ { "year" : 2014 }, { "status" : "A" } ] } }

4. $project/ $unset + $skip序列优化
当有一个$project或$unset之后跟有$skip序列时，$skip 会移至$project之前。
5.$limit+ $limit合并
当$limit紧接着另一个时 $limit，两个阶段可以合并为一个阶段 $limit，其中限制量为两个初始限制量中的
较小者。
6. skip+ $skip 合并
当$skip紧跟另一个$skip，这两个阶段可合并成一个单一的$skip，其中跳过量为总和的两个初始跳过量。
7. $match+ $match合并
当一个$match紧随另一个紧随其后时 $match，这两个阶段可以合并为一个单独 $match的条件 $and
1 { $match: { year: 2014 } },
2 { $match: { status: "A" } }
优化后
1 { $match: { $and: [ { "year" : 2014 }, { "status" : "A" } ] } }
 

4. $project/ $unset + $skip序列优化
当有一个$project或$unset之后跟有$skip序列时，$skip 会移至$project之前。
5.$limit+ $limit合并
当$limit紧接着另一个时 $limit，两个阶段可以合并为一个阶段 $limit，其中限制量为两个初始限制量中的
较小者。
6. skip+ $skip 合并
当$skip紧跟另一个$skip，这两个阶段可合并成一个单一的$skip，其中跳过量为总和的两个初始跳过量。
7. $match+ $match合并
当一个$match紧随另一个紧随其后时 $match，这两个阶段可以合并为一个单独 $match的条件 $and
1 { $match: { year: 2014 } },
2 { $match: { status: "A" } }
优化后
1 { $match: { $and: [ { "year" : 2014 }, { "status" : "A" } ] } }
 

4. $project/ $unset + $skip序列优化
当有一个$project或$unset之后跟有$skip序列时，$skip 会移至$project之前。
5.$limit+ $limit合并
当$limit紧接着另一个时 $limit，两个阶段可以合并为一个阶段 $limit，其中限制量为两个初始限制量中的
较小者。
6. skip+ $skip 合并
当$skip紧跟另一个$skip，这两个阶段可合并成一个单一的$skip，其中跳过量为总和的两个初始跳过量。
7. $match+ $match合并
当一个$match紧随另一个紧随其后时 $match，这两个阶段可以合并为一个单独 $match的条件 $and
1 { $match: { year: 2014 } },
2 { $match: { status: "A" } }
优化后
1 { $match: { $and: [ { "year" : 2014 }, { "status" : "A" } ] } }
 

索引


什么是索引？
索引是特殊的数据结构，它以一种易于遍历的形式存储集合数据集的一小部分。索引存储一个或一组特定
字段的值，按字段的值排序。索引项的排序支持有效的相等匹配和基于范围的查询操作。此外，
MongoDB可以通过使用索引中的排序返回排序后的结果。
WiredTiger: B+
比如基于 B+ tree 的索引数据结构图示如下：
单键索引
如基于主键ID 进行的B+ tree 数据结构

复合索引（复合索引只能支持前缀子查询）

(A,B,C)
基于name， age， position 建立的复合索引
name
name age
name age postion
age :
position
age+ position

索引的特点？
索引支持更快的查询
更快的排序


默认id索引
在创建集合期间，MongoDB 在_id字段上创建唯一索引。该索引可防止客户端插入两个具有相同值的文
档。你不能将_id字段上的index删除。

创建索引：
db.collection.createIndex(<keys>, <options>)
<keys> 指定了创建索引的字段

构造一组数据
1 db.members.insertMany(
2 [
3 {name:"zhangsan",age:19,tags:["00","It","SH"]},
4 {name:"lisi",age:35,tags:["80","It","BJ"]},
5 {name:"wangwu",age:31,tags:["90","It","SZ"]}
6 ]
7 );
创建一个单键索引
1 db.members.createIndex({name:1});
索引的默认名称是索引键和索引中每个键的方向(即1或-1)的连接，使用下划线作为分隔符， 也可以通过指
定 name 来自定义索引名称；
1 db.members.createIndex({name:1}，{ name: "whatever u like."});
对于单字段索引和排序操作，索引键的排序顺序(升序或降序)并不重要，因为MongoDB可以从任何方向遍
历索引。
查询集合中已经存在的索引
1 db.members.getIndexes();
创建一个复合索引
MongoDB支持在多个字段上创建用户定义索引，即 复合索引。
复合索引中列出的字段的顺序具有重要意义。如果一个复合索引由 {name: 1, age: -1} 组成，索引首先按
name 升序排序，然后在每个name值内按 age 降序 排序。
1 db.members.createIndex({ name:1,age:‐1});
对于复合索引和排序操作，索引键的排序顺序(升序或降序)可以决定索引是否支持排序操作。
创建多键索引
MongoDB使用多键索引来索引存储在数组中的内容。如果索引包含数组值的字段，MongoDB为数组的每
个元素创建单独的索引项。数组字段中的每一个元素，都会在多键索引中创建一个键
1 db.members.createIndex( { tags:1});
索引的效果解析
1 db.collection.explain().method(?)
可以使用 explain 进行分析的操作包含 aggregate, count, distinct, find ,group, remove, update
winningPlan： stage 的值含义
COLLSCAN: 整个集合扫描
IXScan: 索引扫描
FETCH: 根据索引指向的文档的地址进行查询
SORT: 需要再内存中排序，效率不高
覆盖查询
当查询条件和查询的<投影>只包含索引字段时，MongoDB直接从索引返回结果，而不扫描任何文档或将
文档带入内存。这些覆盖的查询可能非常高效。
1 db.members.explain().find({ name:"zhangsan"},{_id:0, name:1});
这时不需要 fetch, 可以直接从索引中获取数据。
1 db.members.explain().find().sort( {name:1 ,age:‐1}) ;
使用已创建索引的字段进行排序，能利用索引的顺序，不需要重新排序，效率高
1 db.members.explain().find().sort( {name:1 ,age: 1}) ;
使用未创建索引的字段进行排序， 因为和创建索引时的顺序不一致，所以需要重新排序，效率低
如果需要更改某些字段上已经创建的索引，必须首先删除原有索引，再重新创建新索引，否则，新索引不
会包含原有文档
1 db.collection.dropIndex()
使用索引名称删除索引
1 db.collection.dropIndex("name_1");
使用索引定义删除索引
1 db.collection.dropIndex({name:1,age:‐1});
1 db.collection.createIndex(<keys>, <options>)
<options> 定义了创建索引时可以使用的一些参数，也可以指定索引的特性
索引的唯一性
索引的unique属性使MongoDB拒绝索引字段的重复值。除了唯一性约束，唯一索引和MongoDB其他索
引功能上是一致的
1 db.members.createIndex({age:1},{unique:true});
如果文档中的字段已经出现了重复值，则不可以创建该字段的唯一性索引
如果新增的文档不具备加了唯一索引的字段，则只有第一个缺失该字段的文档可以被添加，索引中该键值
被置为null。
复合键索引也可以具有唯一性，这种情况下，不同的文档之间，其所包含的复合键字段值的组合不可以重
复。
索引的稀疏性
索引的稀疏属性可确保索引仅包含具有索引字段的文档的条目。索引会跳过没有索引字段的文档。
可以将稀疏索引与唯一索引结合使用，以防止插入索引字段值重复的文档，并跳过索引缺少索引字段的文
档。
准备数据：
1 db.sparsedemo.insertMany([{name:"xxx",age:19},{name:"zs",age:20}]);
创建 唯一键，稀疏索引
1 db.sparsedemo.createIndex({name:1},{unique:true ,sparse:true});
如果同一个索引既具有唯一性，又具有稀疏性，就可以保存多篇缺失索引键值的文档了
1 db.sparsedemo.insertOne({name:"zs2w",age:20});
1 db.sparsedemo.insertOne({name:"zs2w2",age:20});
说明：如果只单纯的 唯一键索引，则 缺失索引键的字段，只能有一个
复合键索引也可以具有稀疏性，在这种情况下，只有在缺失复合键所包含的所有字段的情况下，文档才不
会被加入到索引中。
索引的生存时间
针对日期字段，或者包含了日期元素的数组字段，可以使用设定了生存时间的索引，来自动删除字段值超
过生存时间的文档。
构造数据：
1 db.members.insertMany( [
2
3 {
4 name:"zhangsanss",
5 age:19,tags:["00","It","SH"],
6 create_time:new Date()}
7 ] );
8
1 db.members.createIndex({ create_time: 1},{expireAfterSeconds:30 });
在create_time字段上面创建了一个生存时间是30s的索引

复合键索引不具备生存时间的特性

当索引键是包含日期元素的数组字段时，数组中最小的日期将被用来计算文档是否已经过期
数据库使用一个后台线程来监测和删除过期的文档，删除操作可能会有一定的延迟

【MongoDB】--MongoDB的组合索引
寻梦友的博客
04-23 809
本文章主要介绍Mongodb的组合索引的使用。
MongoDB进阶指南！
AS011x的博客
08-28 557
想必大家很多人都在业务开发的时候遇到这样的痛点。最近在用数据库存储数据的时候发现这么一个坑，例如从消息队列中监听消息的时候，原来的做法是将监听的消息json数据存储在数据库，以便好对异常消息数据进行追溯，消息内容使用text类型存储，起初因为数据内容很短，没啥毛病，但是当随着业务的扩展，收到的消息内容越来越长，最后发现数据库中的text字段类型无法很好的支持查询，于是在这个时候，就开始考虑采用更加合适的数据库来存储这种消息数据！...
二、MongoDB聚合操作，索引
Xx__WangQi的博客
04-22 951
一、MongoDB聚合操作 MongoDB聚合框架是一个计算框架作用在一个或几个集合对集合中的数据进行一系列运算 将这些数据转化为期望的形式 如： 现在有一组数据 db.orders.insertMany( [ { zip:"000001", phone:"13101010101", name:"LiuBei", status:"created", shippingFee:10, orderLines:[ {product:"Huawei Meta30 Pro",sku:"2.
MongoDB 索引 聚合
琳琳的博客
05-31 403
createIndex() 方法 MongoDB使用 createIndex() 方法来创建索引。 >db.collection.createIndex(keys, options) >db.col.createIndex({"title":1}) 语法中 Key 值为你要创建的索引字段，1 为指定按升序创建索引，如果你想按降序来创建索引指定为 -1 即可。 createIndex() 方法中你也可以设置使用多个字段创建索引（关系型数据库中称作复合索引）。 >db.col
MongoDB 复合索引
热门推荐
乐沙弥的世界
12-09 2万+
MongoDB支持复合索引，即将多个键组合到一起创建索引。该方式称为复合索引，或者也叫组合索引，该方式能够满足多键值匹配查询使用索引的情形。其次复合索引在使用的时候，也可以通过前缀法来使用索引。MongoDB中的复合索引与关系型数据库基本上一致。在关系型数据库中复合索引使用的一些原则同样适用于MongoDB。本文主要描述MongoDB复合索引。
MongoDB使用详解_2_索引与聚合
KKK
06-07 1518
MongoDB索引与聚合
MongoDB进阶与实战：微服务整合、性能优化、架构管理.docx
09-13
MongoDB 进阶与实战：微服务整合、性能优化、架构管理 MongoDB 是一种流行的开源非关系型数据库（NoSQL），它以文档为模型，使用类似于 JSON 的 BSON 格式进行数据存储。MongoDB 具有强大的查询和索引功能，并且...
速递！MongoDB最新书籍出版啦：MongoDB进阶与实战-微服务整合、性能优化、架构管理
MongoDB中文社区
05-07 892
新书速递 近期，MongoDB中文社区核心成员之一唐卓章老师出了一本MongoDB最新书籍——《MongoDB进阶与实战：微服务整合、性能优化、架构管理》，全面涵盖了MongoDB的基本原理和使用方法、深度的性能分析和应用调优等最佳实践方案，以及基于MongoDB搭建微服务项目的完整上手指导。 本书汇聚了作者在MongoDB微服务开发、性能调优、合理架构部署等方面的丰富经验。书中描述了理想的使用案例，除了给出贴合实际应用的技巧，还涵盖了其中的技术原理，可帮助开发者在MongoDB应用开发方面快速上一个台
MongoDB+集成SpringBoot+索引+并发优化 - 基于《MongoDB进阶与实战：唐卓章》
.
10-21 1万+
如果是通过注解＠Document实现映射的实体类，在MongoDB中都会出现一个叫_class的字段，里面包含的是该实体类的全限定名路径，其实有些多余，是可以去掉的，通过定制TypeMapper的实现来去掉它，在配置类中进行处理// 构造 DefaultMongoTypeMapper 把typeKey设置为空 mongoConverter . setTypeMapper(new DefaultMongoTypeMapper(null));}理想情况下，MongoDB可以提供近似内存式的读写性能。
MongoDB进阶之动态字段设计详解
12-15
本文主要介绍的是关于MongoDB动态字段设计的相关资料，分享出来供大家参考学习，需要的朋友们下面来一起看看详细的介绍吧。 适宜读者人群 MongoDB开发者 基础需求 产品: “我们要为现有的表单增加一个伟大的功能, ...
MongoDB - 索引底层原理和使用，聚合的使用（案例 + 演示）
CYK_byte的博客
01-14 2211
MongoDB 中的索引和 MySQL 索引十分类似，能够极大的提高查询效率，如果没有索引，就需要扫描全集数据，效率非常低. 索引是一种特殊的数据结构，存储在一个易于遍历的读取的数据集合中，是对数据库表中一列或多列值进行排序的一种结构.下图来自于 MongoDB 官方文档：Indexes — MongoDB Manual例如有一个 users 集合，每一个元素都含有 score 这个属性，现在如果需要查询分数小于 30 的文档，在没有索引的情况下就需要扫描全集数据，将符合条件的放到结果集中.为了提升查询效
MongoDB聚合与索引
qq_33840688的博客
08-30 538
目录 聚合 group分组 project显示 Match搜索 sort排序 limit和skip 索引 explain性能分析 索引操作 聚合 聚合就相当于linux中的管道 group分组 以gender字段进行分组 统计每组字段个数 $sum:1代表每条数据记为几 取字段必须加上$ 和引号 分组时_id为空，就将整个文档数据分为为一个组 project显示 b.name.aggr...
MongoDB组合索引
duzm200542901104的专栏
08-17 1万+
MongoDB支持组合索引，就是一个索引结构里面包括一个集合文档的多个字段。下图展示了一个拥有两个字段的组合索引： 组合索引的字段不能超过31个 组合索引查询的时候支持多个字段的匹配   一、创建一个组合索引 创建组合索引的语法格式如下： db.collection.createIndex({field1:type,field2:type2,***}) 跟在字段后面的索引声明描述...
MongoDB中$type、索引、聚合
冲出仁川，走出马德里，故事还会再继续
01-09 998
MongoDB中$type、索引、聚合1、$type1.1 说明1.2 使用2、索引2.1 说明2.2 原理2.3 操作2.4 复合索引3、聚合3.1 说明3.2 使用3.3 常见聚合表达式 最近做的项目用到了MongoDB，所以大概学了下基本操作，写的不好还请见谅。更详细的介绍请移步官网：https://docs.mongodb.com/manual/aggregation/ 1、$type 1.1 说明   $type操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果。   MongoD
03 mongodb索引
qq_37824570的博客
03-30 621
MongoDB索引 索引是一种用来快速查询数据的数据结构。B+Tree就是一种常用的数据库索引数据结构，MongoDB采用B+Tree 做索引，索引创建在colletions上。MongoDB不使用索引的查询，先扫描所有的文档，再匹配符合条件的文档。 使用索引的查询，通过索引找到文档，使用索引能够极大的提升查询效率。 思考：MongoDB索引数据结构是B-Tree还是B+Tree? MongoDB索引数据结构 B-Tree说法来源于官方文档，然后就导致了分歧：有人说MongoDB索引数据结构使用
MongoDB索引
最新发布
2302_79462679的博客
04-22 792
合理使用索引可使MongoDB查询性能提升10-100倍，但需要持续监控和优化。建议：使用分析索引使用情况定期执行explain()分析慢查询explain()分析慢查询结合Compass可视化工具进行索引管理通过深入理解索引机制，结合业务场景设计最优索引策略，可充分发挥MongoDB的高性能优势，构建高效稳定的数据库系统。
MongoDB-索引的使用和索引类型
侯晓阳的博客
09-23 1825
非常详细的MongoDB的索引介绍，针对MongoDB的索引大致可以分为，唯一索引、单列索引、多列索引（复合索引）、多键索引（数组字段索引）、文本搜索索引、地理空间索引，等。
MongoDB实战
如无必要勿增实体
01-27 2671
作用在一个或几个集合上；对集合中的数据进行的一系列运算；将这些数据转化为期望的形式；从效果而言，聚合框架相当于 SQL 查询中的GROUP BY、LEFT OUTER JOIN、AS等。索引是一种用来快速查询数据的数据结构。B+Tree就是一种常用的数据库索引数据结构，MongoDB 采用B+Tree 做索引，索引创建在colletions上。MongoDB不使用索引的查询，先扫描所有的文档，再匹配符合条件的文档。使用索引的查询，通过索引找到文档，使用索引能够极大的提升查询效率。
51.MongoDB聚合操作与索引使用详解
lyw2019的博客
10-27 763
原始数据集 -----------Stage---------》中间结果 ------------Stage--------》中间结果 --------------------》结果集。从效果而言，聚合框架相当于 SQL 查询中的GROUP BY、 LEFT OUTER JOIN 、 AS等。整个聚合运算过程称为管道（Pipeline），由多个阶段（Stage）组成。MongoDB采用B+Tree 做索引，索引创建colletions上。聚合操作允许用户处理多个文档并返回计算结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值