MongoDB关于内嵌数组文档的整理_mongodb 嵌套数组查询

一、关于索引

1】索引数组

假如有一个博客文章的集合，其中每个文档表示一篇文章。每篇文章都有一个"comments"字段，这是一个数组，其中每个元素都是一个评论的子文档。如果想要找出最近被评论次数最多的博客文章，可以在博客文章集合中嵌套的"comments"数组的“date”键上建立索引：

db.blog.createIndex({"comments.date": 1}})

对数组创建索引，实际上是对数组的每一个元素建立一个索引条目，所以如果一篇文章有20条评论，那么它就拥有20个索引条目。因此数组索引的代价比单值索引高：对于单次插入、更新或者删除，每一个数组条目可能都需要更新（可能有上千个索引条目）

与索引对象不同，无法将整个数组作为一个实体创建索引：对数组创建索引，实际上是对数组中的每个元素建立索引，而不是对数组本身建立索引。

在数组上建立的索引并不包含任何位置信息：无法使用数组索引查找特定位置的数组元素，比如："comments.4"

少数特殊情况下，可以对某个特定的数组条目进行索引，比如：

db.blog.createIndex({"comments.10.votes": 1}})

然而，只有在精确匹配第11个数组元素时这个索引才有用

一个索引中的数组字段最多只能有一个。这是为了避免在多键索引中索引条目爆炸性增长：每一对可能的元素都要被索引，这样导致每个文档拥有"n*m"个索引条目。假如有一个{"x":1, "Y":1}上的索引：

//x是一个数组————这是合法的
db.multi.insert({"x" : [1,2,3], "y" : 1})

//y是一个数组————这是合法的
db.multi.insert({"x" : 1, "y" : [1,2,3]})

//x和y都是数组————这是非法的！
db.multi.insert({"x" : [1,2,3], "y" : [4,5,6]})

如果MongoDB要为上面的最后一个例子创建索引，它必须要创建这么多的索引条目：

{"x" : 1, "y" : 4}、{"x" : 1, "y" : 5}、{"x" : 1, "y" : 6}
{"x" : 2, "y" : 4}、{"x" : 2, "y" : 5}、{"x" : 2, "y" : 6}
{"x" : 3, "y" : 4}、{"x" : 3, "y" : 5}、{"x" : 3, "y" : 6}

尽管这些数组只有3个元素。

2】多键索引

对于某个索引的键，如果这个键在某个文档中是一个数组，那么这个索引就会被标记为多键索引（multikey index）。可以从explain()的输出中看到一个索引是否为多键索引：如果使用了多键索引，"isMultikey"字段的值为true。索引只要被标记为多键索引，就无法再变成非多键索引了，即使这个字段为数组的所有文档都从集合中删除。要将多键索引恢复为非多键索引，唯一的方法就是删除再重新创建这个索引。

多键索引可能会比非多键索引慢一些。可能会有多个索引条目指向同一个文档，因此MongoDB在返回结果集时必须要先去除重复的内容。

二、关于单值数组的操作

1】查询

1、操作符：$all

如果需要通过多个元素来匹配数组，就要用"$all"了。这样就会匹配一组元素。例如，假设创建了一个包含3个元素的集合

db.food.insert({"_id" : 1, "fruit": ["apple", "banana", "peach"]})
db.food.insert({"_id" : 2, "fruit": ["apple", "kumquat", "orange"]})
db.food.insert({"_id" : 3, "fruit": ["cherry", "banana", "apple"]})

要找到既有"apple"又有"banana"的文档，可以使用"$all"来查询：

db.food.find({"fruit": {"$all": ["apple", "banana"]}})

---查询结果
db.food.insert({"_id" : 1, "fruit": ["apple", "banana", "peach"]})
db.food.insert({"_id" : 3, "fruit": ["cherry", "banana", "apple"]})

这里的顺序无关紧要。注意，第二个结果中"banana"在"apple"之前。要是对只有一个元素的数组使用"$all"，就和不用"$all"一样了。

也可以使用整个数组进行精确匹配。但是，精确匹配对于缺少元素或者元素冗余的情况就不太灵了。例如，下面的方法会匹配之前的第一个文档：

db.food.find({"fruit": ["apple", "banana", "peach"]})

但是下面这个就不会匹配：

db.food.find({"fruit": ["apple", "banana"]})

这个也不会匹配：

db.food.find({"fruit": ["banana", "apple", "peach"]})

要是想查询数组特定位置的元素，需使用key.index语法指定下标：

db.food.find({"fruit.2": "peach"]})

2、操作符：$size

"$size"对于查询数组来说也是非常有用的，顾名思义，可以用它查询特定长度的数组。例如：

db.food.find({"fruit": {"$size": 1}})

得到一个长度范围内的文档是一种常见的查询。"$size"并不能与其他查询条件（比如 $lte）组合使用，但是这种查询可以通过在文档中添加一个"size"键的方式来实现。这样每一次向指定数组添加元素时，同时增加"size"的值。比如，原本这样的更新：

db.food.update(criteria, {"$push": {"$fruit": "strawberry"}})

就要变成下面这样：

db.food.update(criteria, {"$push": {"$fruit": "strawberry"}, "$inc": {"size": 1}})

自增操作的速度非常快，所以对性能的影响微乎其微。这样存储文档后，就可以像下面这样查询了：

db.food.find({"size": {"$gt": 3}})

很遗憾，这种技巧并不能与"$addToSet"操作符同时使用。

3、操作符：$slice

"$slice"操作符可以返回某个键匹配的数组元素的一个子集。

例如，假设现在有一个博客文章的文档，我们希望返回前10条评论，可以这样做：

db.blog.posts.findOne(criteria, {"comments": {"$slice": 10}})

也可以返回后10条评论，只要在查询条件中使用-10就可以了

db.blog.posts.findOne(criteria, {"comments": {"$slice": -10}})

"$slice"也可以指定偏移值以及希望返回的元素数量，来返回元素集合中间位置的某些结果：

db.blog.posts.findOne(criteria, {"comments": {"$slice": [23, 10]}})

这个操作会跳过前23个元素，返回第24~33个元素。如果数组不够33个元素，则返回23个元素后面的所有元素。

2】新增

如果数组已经存在，"$push"会向已有的数组末尾加入一个元素，要是没有就创建一个新的数组。比如：

db.food.update(criteria, {"$push": {"$fruit": "strawberry"}})

这种一种比较简单的"$push"使用形式，也可以将它应用在一些比较复杂的数组操作中。使用"$each"子操作符，可以通过一次"$push"操作添加多个值。

db.food.update({"_id" : 3}, {"$push": {"fruit" : {"$each" : ["apricot", "grape"]}}})

如果希望数组的最大长度是固定的，那么可以将"$slice"和"$push"组合一起使用，这样就可以保证数组不会超出设定好的最大长度，这实际上就得到了一个最多包含N个元素的数组：

db.food.update({"_id" : 3}, {"$push": {"fruit" : {"$each" : ["apricot", "grape"], "$slice": -10} } })

这个例子会限制数组只包含最后加入的10个元素。"$slice"的值必须是负整数。

如果数组的元素数量小于10（"$push"之后），那么所有元素都会保留。如果数组的元素数量大于10，那么只有最后的10个元素会保留。因此，"$slice"可以用来在文档中创建一个队列。

最后，可以在清理元素之前使用"$sort"，只要向数组中添加子对象就需要清理，例如：

db.movies.update({"genre" :  "horror"}, {
	"$push": {
		"top10" : {
			"$each": [
				{"name": "Nightmare on Elm street", "rating": 5.5},
				{"name": "Saw", "rating": 4.3}
			],
			"$slice": -10,
			"$sort": {"rating": -1}
		} 
	} 
})

这样会根据"rating"字段的值对数组中的所有对象进行排序，然后保留前10个。注意，不能将"$slice"或者"$sort"与"$push"配合使用，且必须使用"$each"。

如果将数组作为数据集使用，保证数组内的元素不会重复，可以用"$addToSet"来实现，如：

db.food.update({"_id" : 3}, {"$addToSet": {"fruit" : "apricot"}})

将"$addToSet"和"$each"组合起来，可以添加多个不同的值，例如：

db.food.update({"_id" : 3}, { "$addToSet": { "fruit" : { "$each" : ["apricot", "grape"] } } })

3】修改

若数组有多个值，而我们只想对其中的一部分进行操作，就需要一些技巧。有两种方法操作数组中的值，通过位置或者定位操作符（"#34;）

通过下标修改数组，如：

db.blog.update({"post" : "postId_1001"}, { "$inc": {"comments.0.votes": 1} })

但是很多情况下，不预先查询文档就不能知道要修改的数组的下标。为了克服这个困难，MongoDB提供了定位操作符"#34;，用来定位查询文档已经匹配的数组元素，并进行更新。例如：

db.blog.update({"comments.author" : "John"}, { "$set": {"comments.$.author": "Jim"} })

4】删除

有几个从数组中删除元素的方法。若是把数组看成队列或者栈，可以用"$pop"，这个修改器可以从数组任何一端删除元素。{"$pop": {"key": 1}}从数组末尾删除一个元素，{"$pop": {"key": -1}}则从头部删除。

有时需要基于特定条件来删除元素，而不仅仅是依据元素的位置，这时可以使用"$pull"。例如：

db.food.update({"_id" : 3}, {"$pull": {"fruit" : "apricot"}})

"$pull"会将所有匹配的文档删除，而不只是删除一个。对数组[1 ,1, 2, 1]执行 pull 1，结果得到只有一个元素的数组 [2]。

三、关于内嵌文档数组的操作

demo订单数据：

{ 
    "total_goods_num" : 3, 
    "goods" : [
        {
            "amount" : 3, 
            "goods_code" : "100009464821", 
            "price" : { "$numberDecimal" : "9999.00" }, 
            "wait_num" : NumberInt(3), 
            "goods_id" : "1007"
        }, 
        {
            "amount" : 4, 
            "goods_code" : "100016079918", 
            "price" : { "$numberDecimal" : "5899.59" }, 
            "wait_num" : NumberInt(4), 
            "goods_id" : "1006"
        }, 
        {
            "amount" : 5, 
            "goods_code" : "100008699547", 
            "price" : { "$numberDecimal" : "4798.37" }, 
            "wait_num" : NumberInt(5), 
            "goods_id" : "1005"
        }
    ], 
    "bill_no" : "D20210712174", 
    "address" : {
        "province" : "安徽省", 
        "city" : "", 
		"area" : "", 
        "detail" : ""
    }, 
    "bill_status" : "1", 
    "pay_time" : ISODate("2022-10-05T03:19:34.506+0000"), 
    "total_money" : { "$numberDecimal" : "15496.33000" }, 
}

1】查询

1、直接使用嵌套字段查询

这样的匹配结果，只要数据组中有包含查询条件的数据，就会返回文档数据

db.getCollection("bill").find({ 'goods.goods_code': "100009464821" })

2、只返回匹配的嵌套数组数据

2.1：可以用$elemMatch操作符 （从mongodb 2.2开始支持）

2.2：可以用$操作符（从mongodb 2.2开始支持）

---- 使用$elemMatch操作符
db.bill.find(
{
   'goods.goods_code': "100009464821" 
},
{
    "goods": {$elemMatch:{"goods_code":"100009464821"}}
}
)

---- 使用$操作符
db.bill.find({'goods.goods_code': "100009464821"}, {_id: 0, 'goods.#39;: 1});

上面两个操作符，官方有这样的说明：the $elemMatch projection returns only the first matching element from the array。也就是说，只会返回匹配到的第一个数据元素。（操作符说明：
https://docs.mongodb.com/manual/reference/operator/projection/elemMatch/#proj._S_elemMatch）

3、使用$filter对数组进行过滤：

3.1：$match中仅过滤主对象字段

3.2：将子对象过滤条件，放在$project中通过"$filter"进行过滤

3.3：若是$match中带着数组字段的查询，当数组没有符合条件的数据时，结果集不返回任何文档信息。当将数组过滤放在$project中通过$filter处理之后，就可以返回文档，而不符合条件的数组键标注的是一个空数组

db.erp_sales_order.aggregate([
 {
	"$match": {
		"$and": [
			{
			"order_id": "orde202209141279id"
			}
		]
	}
 },
 {
	"$project": {
		"perpetual_order": 1,
		"contract_code": 1,
		"erp_sales_order_product": {
			"$filter": {
				"input": "$erp_sales_order_product",
				"as": "erp_sales_order_product",
				"cond": {
					"$or": [
						 {
							"$eq": [
								"$erp_sales_order_product.product_detail_id",
								"espdi20220914331"
							]
						}
					]
				}
			}
		}
	}
 }
])

$filter与$elemMatch和$相比，会把匹配到的所有数组数据都返回。而且排除了不符合条件条件的文档数据。另外，若是数组中没有符合的元素，则返回一个空数组，保留了返回的键，而$elemMatch和$是不会返回键的。比如上面的查询，结果可能如下：

{ 
    "_id" : ObjectId("63218dcd768a5a421db1bfcd"), 
    "perpetual_order" : "0", 
    "contract_code" : "SCON2022081454", 
    "erp_sales_order_product" : []
}

erp_sales_order_product 没有符合条件的数据，仍然返回键

2】修改

1、使用$对数组进行更新

1.1：$操作符只会匹配修改第一条文档

db.bill.update(
{
    "bill_no" : "D20210623173",
    "goods.amount":  {'$gte':4 , '$lte':5}
}, 
{
"$set": {"goods.$.wait_num": 56} 
}
)

按照上面这条语句的查询，"goods.amount"符合条件的数据有2条，但是执行之后，只会更新第一条文档数据（ "goods_id" : "1006"的文档）

2、使用arrayFilters对数组进行更新

2.1：设置 arrayFilters 修改嵌套数组中的一个或者多个元素

2.2：'goods.$[tt].wait_num'中的"$[tt]"，其中"tt"相当于给元素起了一个别名，可以是任何字符串

2.3：在2.2的基础上，arrayFilters中的过滤操作，一定要跟起的别名字符串符合，比如：'tt.amount'，否则就会修改失败

db.bill.updateMany(
{
    "bill_no" : "D20210623173"
},
{
    '$set': {
        'goods.$[tt].wait_num': 36
    }
},
{
	arrayFilters: [
		{'tt.amount': {'$gte':4 , '$lte':5}}
	]
}
)

假设将上面的执行语句调整一下，如下：

db.bill.updateMany(
{
    "bill_no" : "D20210623173"
},
{
    '$set': {
        'goods.$[tt].wait_num': 6
    }
},
{
	arrayFilters: [
		{'elem.amount': {'$gte':4 , '$lte':5}}
	]
}
)

执行之后，会有如下类似的报错：

2022-10-05T11:46:26.597+0800 E QUERY    [js] WriteError: No array filter found for identifier 'tt' in path 'goods.$[tt].wait_num' :

WriteError({
	"index" : 0,
	"code" : 2,
	"errmsg" : "No array filter found for identifier 'tt' in path 'goods.$[tt].wait_num'",
	"op" : {

		"q" : {
			"bill_no" : "D20210623173"
		},

		"u" : {

			"$set" : {
				"goods.$[tt].wait_num" : 6
			}

		},

		"multi" : true,

		"upsert" : false,

		"arrayFilters" : [

			{

				"elem.amount" : {
					"$gte" : 4,
					"$lte" : 5
				}

			}

		]

	}
})

3】删除

3.1：使用$pull操作符

db.bill.update(
{
    "bill_no" : "D20210623173"
}, 
{
"$pull": {"goods": { "amount":  {'$gte':4 , '$lte':5} }} 
}
)