Nhận số lượng phần tử đã lọc trong mảng từ $ lookup cùng với toàn bộ tài liệu

    {
        "$lookup" : {
            "from" : "link",
            "as" : "link",
            "localField" : "_id",
            "foreignField" : "emailGroupId",
            "unwinding" : {
                "preserveNullAndEmptyArrays" : false
            },
            "matching" : {
                "originalLink" : {
                    "$eq" : ""
                }
            }
        }
    }, 
    {
        "$group" : {

Tôi sẽ rời khỏi phần với $ group trong đầu ra đó để chứng minh rằng hai giai đoạn đường ống khác "biến mất". Điều này là do chúng đã được "cuộn lại" vào $ tra cứu giai đoạn đường ống như hình. Trên thực tế, đây là cách MongoDB giải quyết khả năng có thể vượt quá Giới hạn BSON do kết quả "kết hợp" của $ lookup vào một mảng của tài liệu mẹ.

Bạn có thể viết luân phiên thao tác như sau:

Tất cả chi tiết

db.emailGroup.aggregate([
  { "$lookup": {
    "from": "link",
    "localField": "_id",
    "foreignField": "emailGroupId",
    "as": "link"    
  }},
  { "$addFields": {
    "link": {
      "$filter": {
        "input": "$link",
        "as": "l",
        "cond": { "$eq": [ "$$l.originalLink", "" ] }    
      }
    },
    "linkCount": {
      "$sum": {
        "$map": {
          "input": {
            "$filter": {
              "input": "$link",
              "as": "l",
              "cond": { "$eq": [ "$$l.originalLink", "" ] }
            }
          },
          "as": "l",
          "in": { "$size": { "$ifNull": [ "$$l.linkHistory", [] ] } }
        }     
      }
    }    
  }}
])

Nhóm theo partId

db.emailGroup.aggregate([
  { "$lookup": {
    "from": "link",
    "localField": "_id",
    "foreignField": "emailGroupId",
    "as": "link"    
  }},
  { "$addFields": {
    "link": {
      "$filter": {
        "input": "$link",
        "as": "l",
        "cond": { "$eq": [ "$$l.originalLink", "" ] }    
      }
    },
    "linkCount": {
      "$sum": {
        "$map": {
          "input": {
            "$filter": {
              "input": "$link",
              "as": "l",
              "cond": { "$eq": [ "$$l.originalLink", "" ] }
            }
          },
          "as": "l",
          "in": { "$size": { "$ifNull": [ "$$l.linkHistory", [] ] } }
        }     
      }
    }    
  }},
  { "$unwind": "$link" },
  { "$group": {
    "_id": "$partId",
    "linkCount": { "$sum": "$linkCount" } 
  }}
])

Truy vấn nào có cùng đầu ra nhưng "khác" với truy vấn đầu tiên ở chỗ $ filter ở đây được áp dụng "sau" TẤT CẢ kết quả của $ lookup được trả về mảng mới của tài liệu mẹ.

Vì vậy, về mặt hiệu suất, thực sự sẽ hiệu quả hơn nếu làm theo cách đầu tiên cũng như khả năng di chuyển đối với các tập kết quả lớn có thể có "trước khi lọc", điều này sẽ phá vỡ Giới hạn BSON 16MB.

Lưu ý nhỏ cho những ai quan tâm, trong các bản phát hành MongoDB trong tương lai (có lẽ là 3.6 trở lên), bạn có thể sử dụng $ ReplaceRoot thay vì $ addFields với việc sử dụng $ mergeObjects mới nhà điều hành đường ống. Ưu điểm của điều này là như một "khối", chúng ta có thể khai báo "đã lọc" nội dung dưới dạng một biến qua $ let , có nghĩa là bạn không cần phải viết cùng một $ filter "hai lần":

db.emailGroup.aggregate([
  { "$lookup": {
    "from": "link",
    "localField": "_id",
    "foreignField": "emailGroupId",
    "as": "link"    
  }},
  { "$replaceRoot": {
    "newRoot": {
      "$mergeObjects": [
        "$$ROOT",
        { "$let": {
          "vars": {
            "filtered": {
              "$filter": {
                "input": "$link",
                "as": "l",
                "cond": { "$eq": [ "$$l.originalLink", "" ] }    
              }
            }
          },
          "in": {
            "link": "$$filtered",
            "linkCount": {
              "$sum": {
                "$map": {
                  "input": "$$filtered.linkHistory",
                  "as": "lh",
                  "in": { "$size": { "$ifNull": [ "$$lh", [] ] } } 
                }   
              } 
            }  
          }
        }}
      ]
    }
  }}
])

Tuy nhiên, cách tốt nhất để làm như vậy $ lookup hoạt động "vẫn" tại thời điểm này bằng cách sử dụng $ unwind thì $ match mẫu, cho đến khi bạn có thể cung cấp đối số truy vấn cho $ tra cứu trực tiếp.