宜宾网站建设公司

简化MongoDB关联运算-创新互联

MongoDB属于 NoSql 中的基于分布式文件存储的文档型数据库，这种bson格式的文档结构，更加贴近我们对物体各方面的属性描述。而在使用 MongoDB 存储数据的过程中，有时候难免需要进行关联表查询。自从 MongoDB 3.2 版本后，它提供了 $lookup 进行关联表查询，让查询功能改进了不少。但在实现应用场景中，所遇到的环境错综复杂，问题解决也非易事，脚本书写起来也并不简单。好在有了集算器 SPL 语言的协助，处理起来就相对容易多了。
        本文我们将针对 MongoDB 在关联运算方面的问题进行讨论分析，并通过集算器 SPL 语言加以改进，方便用户使用 MongoDB。讨论将分为以下几个部分：
1. 关联嵌套结构情况 1…………………………………………….. 1
2. 关联嵌套结构情况 2…………………………………………….. 3
3. 关联嵌套结构情况 3…………………………………………….. 4
4. 两表关联查询………………………………………………………. 6
5. 多表关联查询………………………………………………………. 8
6. 关联表中的数组查找…………………………………………… 10
Java 应用程序调用 DFX 脚本…………………………………… 12

十多年的平乐网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。成都全网营销推广的优势是能够根据用户设备显示端的尺寸不同，自动调整平乐建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联公司从事“平乐网站设计”,“平乐网站推广”以来，每个客户项目都认真落实执行。
1.关联嵌套结构情况1

两个关联表，表 A 与表 B 中的内嵌文档信息关联, 且返回的信息在内嵌文档中。表 childsgroup 字段 childs 是嵌套数组结构，需要合并的信息 name 在其下。

测试数据：

history:

_ididHistorychild_id
1001today workedch001
2002Workingch004
3003now workingch009

childsgroup:

_idgidnamechilds
1g001group1{"id":"ch001","info":{"name":"a",mobile:1111}},{"id":"ch002","info":{"name":"b",mobile:2222}}
2g002group1{"id":"ch004","info":{"name":"c",mobile:3333}},{"id":"ch009","info":{"name":"d",mobile:4444}}

表History中的child_id与表childsgroup中的childs.id关联，希望得到下面结果：

{
   "_id" : ObjectId("5bab2ae8ab2f1bdb4f434bc3"),
   "id" : "001",
   "history" : "today worked",
   "child_id" : "ch001",
   "childInfo" :  
   {
        "name" : "a",
       " mobile" :  1111
   }
   ………………
}

Mongo 脚本

db.history.aggregate([
   {$lookup: {
      from:  "childsgroup",
      let: {child_id:  "$child_id"},
      pipeline: [
          {$match: {  $expr: { $in: [ "$$child_id", "$childs.id"] } } },
          {$unwind:  "$childs"},
          {$match: {  $expr: { $eq: [ "$childs.id", "$$child_id"] } } },
          {$replaceRoot: {  newRoot: "$childs.info"} }
          ],
          as:  "childInfo"
      }},
 {"$unwind": "$childInfo"}
])

       这个脚本用了几个函数lookup、pipeline、match、unwind、replaceRoot处理，一般 mongodb 用户不容易写出这样复杂脚本；那么我们再看看 spl 脚本是如何实现的：

SPL脚本 ( 文件名：childsgroup.dfx)


AB
1=mongo_open("mongodb://127.0.0.1:27017/raqdb")
2=mongo_shell(A1,"history.find()").fetch()
3=mongo_shell(A1,"childsgroup.find()").fetch()
4=A3.conj(childs)
5=A2.join(child_id,A4:id,info)
6>A1.close()

关联查询结果：

_ididhistorychild_idinfo
1001today workedch001[a,1111]
2002workingch004[c,3333]
3003now workingch009[d,4444]

脚本说明：
      A1：连接 mongodb 数据库。
      A2：获取 history 表中的数据。
      A3：获取 childsgroup 表中的数据。
      A4：将 childsgroup 中的 childs 数据提取出来合并成序表。
      A5：表 history 中的 child_id 与表 childs 中的 id 关联查询，追加 info 字段, 返回序表。
      A6：关闭数据库连接。

      相对 mongodb 脚本写法，SPL 脚本的难度降低了不少，思路也更加清晰，也不需要再去熟悉有关 mongo 函数的用法，以及如何去组合处理数据等，节约了不少时间。

2.关联嵌套结构情况 2

两个关联表，表 A 与表 B 中的内嵌文档信息关联, 将信息合并到内嵌文档中。表 txtPost 字段 comment 是嵌套数组结构，需要把 comment_content 合并到其下。

txtComment：

_IDcomment_nocomment_content
1143test test
2140math

txtPost

_IDpost_noComment
148[{"comment_no"  : 143, "comment_group" : 1} ]
247[{"comment_no"  : 140, "comment_group" : 2}，
 {"comment_no" : 143, "comment_group" : 3} ]

期望结果：

_IDpost_noComment
148[{"comment_no"  : 143, "comment_group" : 1，"comment_content" : "test test"} ]
247[{"comment_no"  : 140, "comment_group" : 2，"comment_content" : "math"}，
 {"comment_no" : 143, "comment_group" : 3，"comment_content" :  "test test"} ]

Mongo 脚本

db.getCollection("txtPost").aggregate([
 { "$unwind": "$comment"},
 {  "$lookup": {

    "from": "txtComment",
    "localField": "comment.comment_no",
    "foreignField": "comment_no",
    "as": "comment.comment_content"
 }},
 { "$unwind": "$comment.comment_content"},
 {  "$addFields": { "comment.comment_content":
 "$comment.comment_content.comment_content" }},
 {  "$group": {
    "_id": "$_id",
    'post_no':{"$first": "$post_no"},
    "comment": {"$push": "$comment"}
    }},
 ]).pretty()

表txtPost 按 comment 拆解成记录，然后与表 txtComment 关联查询,将其结果放到数组中，再将数组拆解成记录，将comment_content 值移到 comment 下，最后分组合并。

SPL 脚本：


AB
1=mongo_open("mongodb://127.0.0.1:27017/raqdb")
2=mongo_shell(A1,"txtPost.find()").fetch()
3=mongo_shell(A1,"txtComment.find()").fetch()
4=A2.conj(comment.derive(A2.post_no:pno))
5=A4.join(comment_no,A3:comment_no,comment_content:Content)
6=A5.group(pno;~:comment)
7>A1.close()

关联查询结果：

pnoComment
47[[ 140, 2，47, …]，[143, 3，47, …] ]
48[[143, 1，48, …]]

脚本说明：
      A1：连接 mongodb 数据库。
      A2：获取 txtPost 表中的数据。
      A3：获取 txtComment 表中的数据。
      A4：将序表 A2 下的 comment 与 post_no 组合成序表，其中 post_no 改名为 pno。
      A5：序表 A4 通过 comment_no 与序表 A3 关联，追加字段 comment_content，将其改名为 Content。
      A6：按 pno 分组返回序表，~ 表示当前记录。
      A7：关闭数据库连接。

      Mongo、SPL 脚本实现方式类似，都是把嵌套结构的数据转换成行列结构的数据，再分组合并。但 SPL 脚本的实现更简单明了。

3.关联嵌套结构情况 3

两个关联表，表 A 与表 B 中的内嵌文档信息关联, 且返回的信息在记录上。表 collection2 字段 product 是嵌套数组结构，返回的信息是 isCompleted 等字段 。

测试数据：
collection1:
{
  _id: '5bc2e44a106342152cd83e97',
  description
   {
     status: 'Good',
     machine: 'X'
    },
  order: 'A',
  lot: '1'
  };
  
collection2：
{
  _id: '5bc2e44a106342152cd83e80',
  isCompleted: false,
  serialNo: '1',
  batchNo: '2',
  product: [ // note the subdocuments here
       {order: 'A', lot: '1'},
       {order: 'A', lot: '2'}
   ]
}

期待结果
{
  _id: 5bc2e44a106342152cd83e97,
  description:
      {
        status: 'Good',
        machine: 'X',
      },
  order: 'A',
  lot: '1' ,
  isCompleted: false,
  serialNo: '1',
  batchNo: '2'
}

Mongo 脚本

db.collection1.aggregate([{
      $lookup:  {

             from:  "collection2",
             let:  {order: "$order", lot: "$lot"},
             pipeline:  [{
                    $match:  {
                    $expr:{ $in: [ { order: "$$order", lot: "$$lot"},  "$product"] }
                    }  
                    }],  
                    as:  "isCompleted"
                    }  
             },  {
                    $addFields:  {
                    "isCompleted":  {$arrayElemAt: [ "$isCompleted", 0] }
                    }  
             },  {
                    $addFields:  { // add the required fields to the top level structure
                    "isCompleted":  "$isCompleted.isCompleted",
                    "serialNo":  "$isCompleted.serialNo",
                    "batchNo":  "$isCompleted.batchNo"
             }  
}])

lookup 两表关联查询，首个 addFields获取isCompleted数组的第一个记录，后一个addFields 转换成所需要的几个字段信息

SPL脚本：


AB
1=mongo_open("mongodb://127.0.0.1:27017/raqdb")
2=mongo_shell(A1,"collection1.find()").fetch()
3=mongo_shell(A1,"collection2.find()").fetch()
4=A3.conj(A2.select(order:A3.product.order,lot:A3.product.lot).derive(A3.serialNo:sno,A3.batchNo:bno))
5＞A1.close()

脚本说明：
      A1：连接 mongodb 数据库。
      A2：获取 collection1 表中的数据。
      A3：获取 collection2 表中的数据。
      A4：根据条件 order, lot 从序表 A2 中查询记录，然后追加序表 A3 中的字段 serialNo, batchNo，返回合并后的序表。
      A5：关闭数据库连接。

      Mongo、SPL 脚本都实现了预期的结果。SPL 很清晰地实现了从数据记录中的内嵌结构中筛选，将符合条件的数据合并成新序表。


4.两表关联查询

从关联表中选择所需要的字段组合成新表。

Collection1:

user1user2income
120.56
130.26

 collection2:

user1user2output
120.3
130.4
230.5

期望结果：

user1user2incomeoutput
120.560.3
130.260.4

Mongo 脚本

db.c1.aggregate([
   {  "$lookup": {
    "from": "c2",
        "localField": "user1",
        "foreignField": "user1",
        "as": "collection2_doc"
    }},
   { "$unwind": "$collection2_doc"},
   {  "$redact": {
        "$cond": [
            {"$eq": [ "$user2",  "$collection2_doc.user2"] },
            "$$KEEP",
            "$$PRUNE"
        ]
    }},
   {  "$project": {
        "user1": 1,
        "user2": 1,
        "income": "$income",
        "output":  "$collection2_doc. output"
    }}
    ]).pretty()

lookup 两表进行关联查询，redact 对记录根据条件进行遍历处理，project 选择要显示的字段。

SPL脚本：


AB
1=mongo_open("mongodb://127.0.0.1:27017/raqdb")
2=mongo_shell(A1,"c1.find()").fetch()
3=mongo_shell(A1,"c2.find()").fetch()
4=A2.join(user1:user2,A3:user1:user2,output)
5>A1.close()

脚本说明：
      A1：连接 mongodb 数据库。
      A2：获取c1表中的数据。
      A3：获取c2表中的数据。
      A4：两表按字段 user1,user2 关联，追加序表 A3 中的 output 字段，返回序表。
      A5：关闭数据库连接。

      Mongo、SPL 脚本都实现了预期的结果。SPL 通过 join 把两个关联表不同的字段合并成新表，与关系数据库用法类似。

5.多表关联查询

多于两个表的关联查询，结合成一张大表。

Doc1:

_idfirstNamelastName
U001shubhamverma

 Doc2:

_iduserIdaddressmob
2U001Gurgaon9876543200

 Doc3:

_iduserIdfbURLstwitterURLs
3U001http://www.facebook.comhttp://www.twitter.com

合并后的结果：
{
   "_id" : ObjectId("5901a4c63541b7d5d3293766"),
   "firstName" : "shubham",
   "lastName" : "verma",
   "address" : {
       "address" : "Gurgaon"
   },
   "social" : {
       "fbURLs" : "http://www.facebook.com",
       "twitterURLs" : "http://www.twitter.com"
   }
}


Mongo 脚本

db.doc1.aggregate([
   {$match:  { _id: ObjectId("5901a4c63541b7d5d3293766") } },
   {
       $lookup:
       {
            from: "doc2",
            localField: "_id",
            foreignField: "userId",
            as: "address"
       }
   },
   {
        $unwind: "$address"
   },
   {
        $project: {
            "address._id": 0,
            "address.userId": 0,
            "address.mob": 0
       }
   },
   {
        $lookup:
       {
            from: "doc3",
            localField: "_id",
            foreignField: "userId",
            as: "social"
       }
   },
   {
        $unwind: "$social"
   },
 
 {  
   $project:  {     
           "social._id": 0,     
           "social.userId": 0
      }
 }
]).pretty();

      由于 Mongodb 数据结构原因，写法也多样化，展示也各不相同。

SPL脚本：


AB
1=mongo_open("mongodb://127.0.0.1:27017/raqdb")
2=mongo_shell(A1,"doc1.find()").fetch()
3=mongo_shell(A1,"doc2.find()").fetch()
4=mongo_shell(A1,"doc3.find()").fetch()
5=A2.join(_id,A3:userId,address,mob)
6=A5.join(_id,A4:userId,fbURLs,twitterURLs)
7>A1.close()

      Mongo、SPL 脚本都实现了预期的结果。此 SPL 脚本与上面例子类似，只是多了一个关联表，每次 join 就新增加字段，最后叠加构成一张大表。

      SPL 脚本的简洁性、统一性非常明显。

6.关联表中的数组查找

从关联表记录数据组中查找符合条件的记录, 用给定的字段组合成新表。

测试数据：

users:

_idNameworkouts
1000xxx[2,4,6]
1002yyy[1,3,5]

workouts:

_idDateBook
11/1/2001Othello
22/2/2001A Midsummer  Night's Dream
33/3/2001The Old  Man and the Sea
44/4/2001GULLIVER’S  TRAVELS
55/5/2001Pickwick  Papers
66/6/2001The Red  and the Black

期望结果：

Name_idDateBook
xxx22/2/2001A  Midsummer Night's Dream
xxx44/4/2001GULLIVER’S  TRAVELS
xxx66/6/2001The Red  and the Black
yyy11/1/2001Othello
yyy33/3/2001The Old  Man and the Sea
yyy55/5/2001Pickwick  Papers

Mongo 脚本

db.users.aggregate([
 { "$lookup": {

   "from" :  "workouts",
   "localField" :  "workouts",
   "foreignField" :  "_id",
   "as" :  "workoutDocumentsArray"
 }},
 {$project: {  _id:0,workouts:0} } ,
 {"$unwind":  "$workoutDocumentsArray"},
 {"$replaceRoot": {  "newRoot": { $mergeObjects:  [ "$$ROOT", "$workoutDocumentsArray"] } } },
 {$project: {  workoutDocumentsArray: 0} }
 ]).pretty()

把关联表 users,workouts 查询结果放到数组中，再将数组拆解，提升子记录的位置，去掉不需要的字段。

SPL脚本 (users.dfx)：


AB
1=mongo_open("mongodb://127.0.0.1:27017/raqdb")
2=mongo_shell(A1,"users.find()").fetch()
3=mongo_shell(A1,"workouts.find()").fetch()
4=A2.conj(A3.select(A2.workouts^~.array(_id)!=[]).derive(A2.name))
5>A1.close()

脚本说明：
      A1：连接 mongodb 数据库。
      A2：获取users表中的数据。
      A3：获取workouts表中的数据。
      A4：查询序表 A3 的 _id 值存在于序表A2中 workouts 数组的记录, 并追加 name 字段。返回合并的序表。
      A5：关闭数据库连接。
      由于需要获取序列的交集不为空为条件，故将 _id 转换成序列。
      Mongo、SPL 脚本都实现了预期的结果。从脚本实现过程来看，SPL 集成度高而又不失灵活性，让程序简化了不少。

7.Java 应用程序调用 DFX 脚本

      在通过 SPL 脚本对 MongoDB 数据进行了关联计算后，其结果可以被 java 应用程序很容易地使用。集算器提供了 JDBC 驱动程序，用 JDBC 存储过程方式访问，与调用存储过程相同。（JDBC 具体配置参考《集算器教程》中的“ JDBC 基本使用”章节 ）
   Java 调用主要过程如下：
   public void testUsers(){
      Connection con = null;
      com.esproc.jdbc.InternalCStatement st;
       try{
        // 建立连接
        Class.forName("com.esproc.jdbc.InternalDriver");
        con= DriverManager.getConnection("jdbc:esproc:local://");
        // 调用存储过程，其中 users 是 dfx 的文件名
        st =(com. esproc.jdbc.InternalCStatement)con.prepareCall("call users>  ()");
        // 执行存储过程
        st.execute();
        // 获取结果集
        ResultSet rs = st.getResultSet();
         。。。。。。。
   catch(Exception e){
        System.out.println(e);
   }
       可以看到，使用时按标准的 JDBC 方法操作，集算器很方便嵌入到 Java 应用程序中。同时，集算器也支持 ODBC 驱动，因此集成到其它支持 ODBC 的语言也非常容易。

       Mongo 存储的数据结构相对关系数据库更复杂、更灵活，其提供的查询语言也非常强、适应面广，同时需要了解函数也不少，函数之间的结合更是变化无穷，因此要熟练掌握并应用也并非易事。集算器的离散性、易用性恰好能弥补 Mongo 这方面的不足，在降低 mongo 学习成本及使用复杂度、难度的同时，让 mongo 的功能得到更充分的展现。

另外有需要云服务器可以了解下创新互联scvps.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。


网页名称：简化MongoDB关联运算-创新互联
文章转载：http://ybzwz.com/article/dsgese.html

其他资讯