详解MongoDB中的多表关联查询（$lookup）

虎玩堂 發表於 2018-12-3 01:42:00

详解MongoDB中的多表关联查询（$lookup）

<h2>一.  聚合框架 </h2>
聚合框架是MongoDB的高级查询语言，它允许我们通过转换和合并多个文档中的数据来生成新的单个文档中不存在的信息。
聚合管道操作主要包含下面几个部分：
<table style="height: 287px; width: 324px" border="0">
<tbody>
<tr>
<td style="text-align: center">命令</td>
<td style="text-align: center">功能描述</td>
</tr>
<tr>
<td style="text-align: left">$project</td>
<td style="text-align: left">指定输出文档里的字段.</td>
</tr>
<tr>
<td style="text-align: left">$match</td>
<td style="text-align: left">选择要处理的文档，与fine()类似。</td>
</tr>
<tr>
<td style="text-align: left">$limit</td>
<td style="text-align: left">限制传递给下一步的文档数量。</td>
</tr>
<tr>
<td style="text-align: left">$skip</td>
<td style="text-align: left">跳过一定数量的文档。</td>
</tr>
<tr>
<td style="text-align: left">$unwind</td>
<td style="text-align: left">扩展数组，为每个数组入口生成一个输出文档。</td>
</tr>
<tr>
<td style="text-align: left">$group</td>
<td style="text-align: left">根据key来分组文档。</td>
</tr>
<tr>
<td style="text-align: left">$sort</td>
<td style="text-align: left">排序文档。</td>
</tr>
<tr>
<td style="text-align: left">$geoNear</td>
<td style="text-align: left">选择某个地理位置附近的的文档。</td>
</tr>
<tr>
<td style="text-align: left">$out</td>
<td style="text-align: left">把管道的结果写入某个集合。</td>
</tr>
<tr>
<td style="text-align: left">$redact</td>
<td style="text-align: left">控制特定数据的访问。</td>
</tr>
<tr>
<td style="text-align: left">
$lookup
</td>
<td style="text-align: left">多表关联（3.2版本新增）</address></td>
</tr>
</tbody>
</table>
在本篇幅中，我们聚焦$lookup的使用。
<h2>二.  $lookup的功能及语法</h2>
1. 主要功能 是将每个输入待处理的文档，经过$lookup 阶段的处理，输出的新文档中会包含一个新生成的数组列（户名可根据需要命名新key的名字）。数组列存放的数据是来自被Join 集合的适配文档，如果没有，集合为空（即为[ ]）
2. 基本语法
<div class="cnblogs_code">
<pre>{
$lookup:
{
 from: <collection to join>,
 localField: <field from the input documents>,
 foreignField: <field from the documents of the "from" collection>,
 as: <output array field>
}
}</pre>
</div>
 3. 语法的解释说明
<table border="0">
<tbody>
<tr>
<td style="text-align: center">语法值</td>
<td style="text-align: center">解释说明</td>
</tr>
<tr>
<td style="text-align: left">
<pre>from</pre>
</td>
<td>同一个数据库下等待被Join的集合。</td>
</tr>
<tr>
<td>
<pre>localField</pre>
</td>
<td>
源集合中的match值，如果输入的集合中，某文档没有 localField
这个Key（Field），在处理的过程中，会默认为此文档含
有 localField：null的键值对。
</td>
</tr>
<tr>
<td>
<pre>foreignField</pre>
</td>
<td>待Join的集合的match值，如果待Join的集合中，文档没有foreignField 值，在处理的过程中，会默认为此文档含有 foreignField：null的键值对。</td>

</tr>
<tr>
<td>
<pre>as</pre>
</td>
<td>为输出文档的新增值命名。如果输入的集合中已存在该值，则会覆盖掉，</td>
</tr>
</tbody>
</table>
 
（注：null = null 此为真）
其语法功能类似于下面的伪SQL语句：
<div class="cnblogs_code">
<pre>SELECT *, <output array field>
FROM collection
WHERE <output array field> IN (SELECT *
 FROM <collection to join>
 WHERE <foreignField>= <collection.localField>);</pre>
</div>
 
<h2>三. 案例</h2>
以上的语法介绍有些枯燥，不易理解，我们直接分析品味案例好了。
假设有 订单集合，存储的测试数据如下：
<div class="cnblogs_code">
<pre>db.orders.insert([
{ "_id" : 1, "item" : "almonds", "price" : 12, "quantity" : 2 },
{ "_id" : 2, "item" : "pecans", "price" : 20, "quantity" : 1 },
{ "_id" : 3}
])</pre>
</div>
其中 item 对应数据为 商品名称。
另外一个就是就是 商品库存集合 ，存储的测试数据如下：
<div class="cnblogs_code">
<pre>db.inventory.insert([
{ "_id" : 1, "sku" : "almonds", description: "product 1", "instock" : 120 },
{ "_id" : 2, "sku" : "bread", description: "product 2", "instock" : 80 },
{ "_id" : 3, "sku" : "cashews", description: "product 3", "instock" : 60 },
{ "_id" : 4, "sku" : "pecans", description: "product 4", "instock" : 70 },
{ "_id" : 5, "sku": null, description: "Incomplete" },
{ "_id" : 6 }
])</pre>
</div>
此集合中的 sku 数据等同于订单集合中的 商品名称。
在这种模式设计下，如果要查询订单表对应商品的库存情况，应如何写代码呢？
很明显这需要两个集合Join。
场景简单，不做赘述，直送答案。其语句如下：
<div class="cnblogs_code">
<pre>db.orders.aggregate([
{
$lookup:
 {
 from: "inventory",
 localField: "item",
 foreignField: "sku",
 as: "inventory_docs"
 }
}
])</pre>
</div>
返回的执行结果如下：
<div class="cnblogs_code">
<pre>{
"_id" : NumberInt("1"),
"item" : "almonds",
"price" : NumberInt("12"),
"quantity" : NumberInt("2"),
"inventory_docs" : [
 {
 "_id" : NumberInt("1"),
 "sku" : "almonds",
 "description" : "product 1",
 "instock" : NumberInt("120")
 }
]
}

{
"_id" : NumberInt("2"),
"item" : "pecans",
"price" : NumberInt("20"),
"quantity" : NumberInt("1"),
"inventory_docs" : [
 {
 "_id" : NumberInt("4"),
 "sku" : "pecans",
 "description" : "product 4",
 "instock" : NumberInt("70")
 }
]
}

{
"_id" : NumberInt("3"),
"inventory_docs" : [
 {
 "_id" : NumberInt("5"),
 "sku" : null,
 "description" : "Incomplete"
 },
 {
 "_id" : NumberInt("6")
 }
]
}</pre>
</div>
 
分析查询语句和结果，回扣$lookup定义，可以将上面的处理过程，描述如下：
从集合order中逐个获取文档处理，拿到一个文档后，会根据localField 值 遍历被 Join的 inventory集合（from: "inventory"），看inventory集合文档中 foreignField值是否与之相等。如果相等，就把符合条件的inventory文档  整体内嵌到聚合框架新生成的文档中，并且新key 统一命名为 inventory_docs。考虑到符合条件的文档不唯一，这个Key对应的Value是个数组形式。原集合中Key对应的值为Null值或不存在时，需特别小心。
<h2>四. 说明</h2>
在以下的说明中，为描述方便，将 from对应的集合定义为 被join集合；待聚合的表成为源表； 将 localField 和 foreignField 对应的Key 定义 比较列。
1. 因客户端工具显示的问题，上面示例中查询结果重Int 类型值都自动显示为了 NumberInt("")。这个NumberInt标注，请忽略，不影响我们的功能测试。
2. 这个示例中，一共输出了三个文档，在没有再次聚合（$match）的条件下，这个输出文档数量是以输入文档的数量来决定的（由order来决定），而不是以被Join的集合（inventory）文档数量决定。
3. 在此需要特别强调的是输出的第三个文档。在源库中原文档没有要比较的列（即item值不存在，既不是Null值，也不是值为空），此时和被Join 集合比较，如果被Join集合中比较列也恰好为NUll 或不存在的值，此时，判断相等，即会把 被Join集合中比较列为NUll 或值不存在文档吸收进来。
4. 假设源表（order）中比较列为某一个值，而此值在待比较表（inventory）的所有文档中都不存在，那么查询结果会是什么样子呢？
order 集合在现有数据的基础上，再被insert 进一笔测试数据，这个订单的商品为 Start，在库存商品中根本没有此数据。
<div class="cnblogs_code">
<pre>db.orders.insert({"_id" : 4, "item" : "Start", "price" : 2000, "quantity" : 1 })</pre>
</div>
order集合的文档数量由之前的3个增长为4个。
再次执行查询
<div class="cnblogs_code">
<pre>db.orders.aggregate([
{
$lookup:
 {
 from: "inventory",
 localField: "item",
 foreignField: "sku",
 as: "inventory_docs"
 }
}
])</pre>
</div>
此时查看结果 
<div class="cnblogs_code">
<pre>{
"_id" : NumberInt("1"),
"item" : "almonds",
"price" : NumberInt("12"),
"quantity" : NumberInt("2"),
"inventory_docs" : [
 {
 "_id" : NumberInt("1"),
 "sku" : "almonds",
 "description" : "product 1",
 "instock" : NumberInt("120")
 }
]
}

{
"_id" : NumberInt("2"),
"item" : "pecans",
"price" : NumberInt("20"),
"quantity" : NumberInt("1"),
"inventory_docs" : [
 {
 "_id" : NumberInt("4"),
 "sku" : "pecans",
 "description" : "product 4",
 "instock" : NumberInt("70")
 }
]
}

{
"_id" : NumberInt("3"),
"inventory_docs" : [
 {
 "_id" : NumberInt("5"),
 "sku" : null,
 "description" : "Incomplete"
 },
 {
 "_id" : NumberInt("6")
 }
]
}

{
"_id" : NumberInt("4"),
"item" : "Start",
"price" : NumberInt("2000"),
"quantity" : NumberInt("1"),
"inventory_docs" : [ ]
}</pre>
</div>
 查询出的结果也由之前的3个变成了4个。比较特别的是第四个文档，其新增列为 "inventory_docs" : [ ] ，即值为空 。所以，此时，实现的功能非常像关系型数据库的 left join。
那么，可不可以只筛选出新增列为空的文档呢？
即我们查询出，比较列的条件下，刷选出只在A集合中，而不在集合B的文档呢？就像关系数据库中量表Join的 left join on a.key =b.key where b.key is null .
答案是可以的。
其实回到聚合框架上来，再次聚合一下就可以了，来一次$match就可以了。
执行的语句调整一下就OK了。
<div class="cnblogs_code">
<pre>db.orders.aggregate([
{
$lookup:
 {
 from: "inventory",
 localField: "item",
 foreignField: "sku",
 as: "inventory_docs"
 }
},
{ $match : {"inventory_docs" : [ ]} }
])</pre>
</div>
执行结果为 
<div class="cnblogs_code">
<pre>{
"_id" : NumberInt("4"),
"item" : "Start",
"price" : NumberInt("2000"),
"quantity" : NumberInt("1"),
"inventory_docs" : [ ]
}</pre>
</div>
可以看出执行结果只有一个文档。这个文档表明的含义是：订单中有这个商品，但是库存中没有这个商品。
（$look只是聚合框架的一个stage，在其前前后后，都可以嵌入到其他的聚合管道的命令，例如$match.$group等。下面的说明5，也可以说明一二）
5. 以上的比较列都是单一的Key/Value,如果复杂一点，如果比较的列是数组，我们又该如何关联呢？
我们接下来再来测试一把。将之前集合order 、inventory 插入的数据清空。
插入此场景下的新数据，向order中插入的数据，如下：
<div class="cnblogs_code">
<pre>db.orders.insert({ "_id" : 1, "item" : "MON1003", "price" : 350, "quantity" : 2, "specs" :[ "27 inch", "Retina display", "1920x1080" ], "type" : "Monitor" })</pre>
</div>
<pre>specs 对应的value是数组格式。</pre>
向集合inventory 新插入的数据如下：
<div class="cnblogs_code">
<pre>db.inventory.insert({ "_id" : 1, "sku" : "MON1003", "type" : "Monitor", "instock" : 120,"size" : "27 inch", "resolution" : "1920x1080" })

db.inventory.insert({ "_id" : 2, "sku" : "MON1012", "type" : "Monitor", "instock" : 85,"size" : "23 inch", "resolution" : "1280x800" })

db.inventory.insert({ "_id" : 3, "sku" : "MON1031", "type" : "Monitor", "instock" : 60,"size" : "23 inch", "display_type" : "LED" })</pre>
</div>
查询的语句如下：
<div class="cnblogs_code">
<pre>db.orders.aggregate([
{
 $unwind: "$specs"
},
{
 $lookup:
 {
 from: "inventory",
 localField: "specs",
 foreignField: "size",
 as: "inventory_docs"
 }
},
{
 $match: { "inventory_docs": { $ne: [] } }
}
])</pre>
</div>
查询显示结果如下：
<div class="cnblogs_code">
<pre>{
"_id" : NumberInt("1"),
"item" : "MON1003",
"price" : NumberInt("350"),
"quantity" : NumberInt("2"),
"specs" : "27 inch",
"type" : "Monitor",
"inventory_docs" : [
 {
 "_id" : NumberInt("1"),
 "sku" : "MON1003",
 "type" : "Monitor",
 "instock" : NumberInt("120"),
 "size" : "27 inch",
 "resolution" : "1920x1080"
 }
]
}</pre>
</div>
仔细看啊，输出文档中的 specs 对应的数据变成了字符串类型（原集合为数组）。是什么发挥了如此神奇功效？？？，请看黑板，请将目光集中在
<pre>{
 $unwind: "$specs"
}</pre>
还有个小问题，大家猜一下，如果查询语句中没有
<pre>{
 $match: { "inventory_docs": { $ne: [] } }
} 结果会是什么样呢？即查看语句修改为：</pre>
<div class="cnblogs_code">
<pre>db.orders.aggregate([
{
 $unwind: "$specs"
},
{
 $lookup:
 {
 from: "inventory",
 localField: "specs",
 foreignField: "size",
 as: "inventory_docs"
 }
}
])</pre>
</div>
大家猜猜看！
大家猜猜看！
大家猜猜看！
呵呵...此时的结果是：
<div class="cnblogs_code">
<pre>文档1
{
"_id" : NumberInt("1"),
"item" : "MON1003",
"price" : NumberInt("350"),
"quantity" : NumberInt("2"),
"specs" : "27 inch",
"type" : "Monitor",
"inventory_docs" : [
 {
 "_id" : NumberInt("1"),
 "sku" : "MON1003",
 "type" : "Monitor",
 "instock" : NumberInt("120"),
 "size" : "27 inch",
 "resolution" : "1920x1080"
 }
]
}

文档2
{
"_id" : NumberInt("1"),
"item" : "MON1003",
"price" : NumberInt("350"),
"quantity" : NumberInt("2"),
"specs" : "Retina display",
"type" : "Monitor",
"inventory_docs" : [ ]
}

文档3

{
"_id" : NumberInt("1"),
"item" : "MON1003",
"price" : NumberInt("350"),
"quantity" : NumberInt("2"),
"specs" : "1920x1080",
"type" : "Monitor",
"inventory_docs" : [ ]
}</pre>
</div>
你推算出正确结果了吗？
6. 最后一道题，在SQL中两表关联，每个表都有条件，那么在MongoDB中应该如何书写呢？
例如SQL Server 语句
<div class="cnblogs_code">
<pre> SELECT * FROM dbo.Rel_QQDetails AS D
JOIN dbo.Fct_QQStatements AS S ON D.OrderId=s.OrderStatementsId
WHERE D.ReconciliationId='te54test7-187e-4e38-85e7-88926000aa7a'
AND S.StatementsPriceException='false'</pre>
</div>
转换后的MongoDB代码为：
<div class="cnblogs_code">
<pre>db.Rel_QQDetails.aggregate([
{ $match: {ReconciliationId:CSUUID("bb54bee7-187f-4d38-85d7-88926000ac7a")}},
{ $lookup:
 {
 from: "Fct_QQStatements",
 localField: "OrderId",
 foreignField: "OrderStatementsId",
 as: "inventory_docs"
 }
},
{ $match : {"inventory_docs.StatementsPriceException" :false} }
])</pre>
</div>
 
7. 附加题，mongodb 集合间关联后更新，在MongoDB中应该如何书写呢？----借助 forEach 功能
由于篇幅限制，集合中的数据格式不再说明。
需求：集合QQ_OrderReturn 和 RelQQ_ReconciliationDetails 关联刷选，刷选符合条件，在更新QQ_OrderReturn的数据。
 
<div class="cnblogs_code">
<pre>db.QQ_OrderReturn.aggregate([
{$match:{"Status" : 21}},
 {$match:{"Disabled" : 0}},
 {$match:{"JoinResponParty" : "合作方"}},

{$match:{ SupplierSellerName:"(合作营)ABC阳澄湖蟹"}},

{
$lookup:
 {
 from: "RelQQ_ReconciliationDetails",
 localField: "OrderReturnId",
 foreignField: "OrderId",
 as: "inventory_docs"
 }
},
{ $match : {"inventory_docs" : [ ]} }
]).forEach(function(item){
db.QQ_OrderReturn.update({"_id":item._id},{$set:{"Status":NumberInt(0)}})

})</pre>
</div>
 
 
谢谢！！！
希望以上的讲解和演示能对大家学习$lookup有所帮助。
 
 
注：以上案例数据参考MongoDB官方网站，大家也可访问官网获取更多、更全的相关知识。
 
本文版权归作者所有，未经作者同意不得转载,谢谢配合！！！
<pre> </pre> 
来源：https://www.cnblogs.com/xuliuzai/p/10055535.html

頁: [1]

琼殿技术论坛's Archiver

详解MongoDB中的多表关联查询（$lookup）