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

一. 聚合框架

聚合框架是MongoDB的高级查询语言，它允许们通过转换和合并多个文档中的数据来生成新的单个文档中不存在的信息。

聚合管道操作主要包含下面几个部分：

|---------------|-----------------------|
| **命令**        | **功能描述**              |
| $project      | 指定输出文档里的字段.           |
| $match        | 选择要处理的文档，与fine()类似。   |
| $limit        | 限制传递给下一步的文档数量。        |
| $skip         | 跳过一定数量的文档。            |
| $unwind       | 扩展数组，为每个数组入口生成一个输出文档。 |
| $group        | 根据key来分组文档。           |
| $sort         | 排序文档。                 |
| $geoNear      | 选择某个地理位置附近的的文档。       |
| $out          | 把管道的结果写入某个集合。         |
| $redact       | 控制特定数据的访问。            |
| ***$lookup*** | ***多表关联（3.2版本新增）***   |

在本篇幅中，们聚焦$lookup的使用。

二. $lookup的功能及语法

1. 主要功能是将每个输入待处理的文档，经过$lookup 阶段的处理，输出的新文档中会包含一个新生成的数组列（户名可根据需要命名新key的名字 ）。数组列存放的数据 是 来自 被Join 集合的适配文档，如果没有，集合为空（即 为[ ]） 2. 基本语法

{
   $lookup:
     {
       from: <collection to join>,
       localField: <field from the input documents>,
       foreignField: <field from the documents of the "from" collection>,
       as: <output array field>
     }
}

3. 语法的解释说明

|----------------------|--------------------------------------------------------------------------------------------|
| **语法值**              | **解释说明**                                                                                   |
| ``` from ```         | 同一个数据库下等待被Join的集合。                                                                         |
| ``` localField ```   | 源集合中的match值，如果输入的集合中，某文档没有 localField 这个Key（Field），在处理的过程中，会默认为此文档含 有 localField：null的键值对。 |
| ``` foreignField ``` | 待Join的集合的match值，如果待Join的集合中，文档没有foreignField 值，在处理的过程中，会默认为此文档含有 foreignField：null的键值对。    |
| ``` as ```           | 为输出文档的新增值命名。如果输入的集合中已存在该值，则会覆盖掉，                                                           |

（注：null = null 此为真）

其语法功能类似于下面的伪SQL语句：

SELECT *, <output array field>
FROM collection
WHERE <output array field> IN (SELECT *
                               FROM <collection to join>
                               WHERE <foreignField>= <collection.localField>);

三. 案例

以上的语法介绍有些枯燥，不易理解，们直接分析品味案例好了。

假设 有 订单集合， 存储的测试数据 如下：

db.orders.insert([
   ,
   ,

])

其中 item 对应 数据为 商品名称。

另外 一个 就是就是商品库存集合 ，存储的测试数据 如下：

db.inventory.insert([
   ,
   ,
   ,
   ,
   ,

])

此集合中的 sku 数据等同于 订单 集合中的 商品名称。

在这种模式设计下，如果要查询订单表对应商品的库存情况，应如何写代码呢？ 很明显这需要两个集合Join。

场景简单，不做赘述，直送答案 。其语句 如下：

db.orders.aggregate([
   {
     $lookup:
       {
         from: "inventory",
         localField: "item",
         foreignField: "sku",
         as: "inventory_docs"
       }
  }
])

返回的执行结果如下：

{
    "_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")
        }
    ]
}

分析查询语句和结果，回扣$lookup定义，可以将上面的处理过程，描述如下：

从集合order中逐个获取文档处理，拿到一个文档后，会根据localField 值 遍历 被 Join的 inventory集合（from: “inventory”），看inventory集合文档中 foreignField值是否与之相等。如果相等，就把符合条件的inventory文档 整体 内嵌到聚合框架新生成的文档中，并且新key 统一命名为 inventory_docs。考虑到符合条件的文档不唯一，这个Key对应的Value是个数组形式。原集合中Key对应的值为Null值或不存在时，需特别小心。

四. 说明

在以下的说明中，为描述方便，将 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，在库存商品中根本没有此数据。

db.orders.insert()

order集合的文档数量由之前的3个增长为4个。

再次执行查询

db.orders.aggregate([
   {
     $lookup:
       {
         from: "inventory",
         localField: "item",
         foreignField: "sku",
         as: "inventory_docs"
       }
  }
])

此时查看结果

{
    "_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" : [ ]
}

查询出的结果也由之前的3个变成了4个。比较特别的是第四个文档 ，其新增列 为 “inventory_docs” : [ ] ，即值为空 。所以，此时，实现的功能非常像关系型数据库的 left join。

那么，可不可以只筛选出新增列为空的文档呢？

即 们查询出 ，比较列的条件下，刷选出只在A集合中，而不在集合B的文档呢？ 就像关系数据库中量表Join的left join on a.key =b.key where b.key is null . 答案是可以的。

其实回到聚合框架上来，再次聚合一下就可以了，来一次$match就可以了。

执行的语句调整一下就OK了。

db.orders.aggregate([
   {
     $lookup:
       {
         from: "inventory",
         localField: "item",
         foreignField: "sku",
         as: "inventory_docs"
       }
  },
   }
])

执行结果 为

{
    "_id" : NumberInt("4"),
    "item" : "Start",
    "price" : NumberInt("2000"),
    "quantity" : NumberInt("1"),
    "inventory_docs" : [ ]
}

可以看出执行结果只有一个文档。这个文档表明的含义是：订单中有这个商品，但是库存中没有这个商品。

（$look只是聚合框架的一个stage，在其前前后后，都可以嵌入到其他的聚合管道的命令，例如$match.$group等。下面的说明5，也可以说明一二） 5.以上的比较列都是单一的Key/Value,如果复杂一点，如果比较的列是数组，们又该如何关联呢？

们接下来再来测试一把。将之前 集合order 、inventory 插入的数据清空。

插入此场景下的新数据，向order中插入的数据，如下：

db.orders.insert({ "_id" : 1, "item" : "MON1003", "price" : 350, "quantity" : 2, "specs" :[ "27 inch", "Retina display", "1920x1080" ], "type" : "Monitor" })

specs 对应的value是数组格式。

向集合inventory 新插入的数据 如下：

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" })

查询的语句如下：

db.orders.aggregate([
   {
      $unwind: "$specs"
   },
   {
      $lookup:
         {
            from: "inventory",
            localField: "specs",
            foreignField: "size",
            as: "inventory_docs"
        }
   },
   {
      $match:  }
   }
])

查询显示结果如下：

{
    "_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"
        }
    ]
}

仔细看啊，输出文档中的 specs 对应的数据变成了字符串类型（原集合为数组）。是什么发挥了如此神奇功效？？？，请看黑板，请将目光集中在

{
      $unwind: "$specs"
   }

还有个小问题，大家猜一下，如果查询语句中没有

{
      $match:  }
   }

结果会是什么样呢？即查看语句修改为：

db.orders.aggregate([
   {
      $unwind: "$specs"
   },
   {
      $lookup:
         {
            from: "inventory",
            localField: "specs",
            foreignField: "size",
            as: "inventory_docs"
        }
   }
])

大家猜猜看！

大家猜猜看！

大家猜猜看！

呵呵…此时的结果是：

文档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" : [ ]
}

你推算出正确结果了吗？

1. 最后一道题，在SQL中两表关联，每个表都有条件，那么在MongoDB中应该如何书写呢？

例如SQL Server 语句

 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'

转换后的MongoDB代码为：

  db.Rel_QQDetails.aggregate([
   },
    { $lookup:
       {
         from: "Fct_QQStatements",
         localField: "OrderId",
         foreignField: "OrderStatementsId",
         as: "inventory_docs"
       }
  },
     }
])

1. 附加题，mongodb 集合间关联后更新，在MongoDB中应该如何书写呢？—-借助 forEach 功能

由于篇幅限制，集合中的数据格式不再说明。

需求：集合QQ_OrderReturn 和 RelQQ_ReconciliationDetails 关联刷选，刷选符合条件，在更新QQ_OrderReturn的数据。

db.QQ_OrderReturn.aggregate([
     },
         },
        },

},

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

})

谢谢！！！

希望以上的讲解和演示能对大家学习$lookup有所帮助。 注：以上案例数据参考MongoDB官方网站，大家也可访问官网获取更多、更全的相关知识。 本文版权归作者所有，未经作者同意不得转载,谢谢配合！！！

原文创作：东山絮柳仔

原文链接：https://www.cnblogs.com/xuliuzai/p/10055535.html

文章列表

• 通过Python收集MySQL MHA 部署及运行状态信息的功能实现
• 通过Python将监控数据由influxdb写入到MySQL
• 通过Python实现生成excel并邮件发送的功能
• 通过Python实现对SQL Server 数据文件大小的监控告警
• 通过 Telegraf + InfluxDB + Grafana 快速搭建监控体系的详细步骤
• 迁移Report Server DataBase时遇到的坑
• 谨慎 mongodb 关于数字操作可能导致类型及精度变化
• 详解MongoDB中的多表关联查询$lookup
• 瞧一瞧！这儿实现了MongoDB的增量备份与还原含部署代码
• 时序数据库InfluxDB的基本语法
• 数据库服务器资源使用情况周报
• 数据库如何应对保障大促活动
• 我10亿级ES数据迁到MongoDB节省90%成本!转载
• 应用部署架构演进转载 -
• 学习ProxySQL参考到几个网址
• 名言小抄五
• 关于SQL Server 镜像数据库快照的创建及使用
• 关于SQL Server 数据库归档的一些思考和改进
• 关于MongoDB时间格式转换和时间段聚合统计的用法总结
• 以实现MongoDB副本集状态的监控为例，看Telegraf系统中Exec输入插件如何编写部署
• 一个磁盘I/O故障导致的AlwaysOn FailOver 过程梳理和分析
• shell 操作钉钉机器人实现告警提醒
• python 学习笔记 四
• python 学习 三
• kapacitor的安装及部分常用命令
• TiDB 架构及设计实现
• TiDB 学习笔记一运维管理
• SQL Server 查看当前会话状态sp_WhoIsActive 转载 -
• SQL Server DB迁移工作List
• SQL Server CPU 利用率毛刺的分析定位与解决
• SQL Server Alwayson架构下 服务器 各虚拟IP漂移监控告警的功能实现 1服务器视角
• Python发送的邮件设置收件人隐藏与显示
• MySQL索引设计需要考虑哪些因素？
• MySQL日志收集之Filebeat和Logstsh的一键安装配置ELK架构
• MySQL数据归档小工具推荐及优化mysql_archiver
• MySQL数据库规范 设计规范+开发规范+操作规范
• MySQL数据库Inception工具学习与测试 笔记
• MySQL常用命令汇总偏向运维管理
• MySQL在线DDL工具 ghost
• MySQL 学习笔记四
• MySQL 学习笔记三
• MySQL alter table时执行innobackupex全备再谈Seconds_Behind_Master
• MySQL MHA 运行状态监控
• MongoDB数据库的设计规范
• MongoDB实例重启失败探究大事务Redo导致
• MongoDB 那些事一文以蔽之
• MongoDB 中的加减乘除 - 运算
• MongoDB 中数据的替换方法实现 类Replace函数功能
• Linux常用命令总结二
• K8S基础学习