Jak mogę zmniejszyć etapy rozwijania w potoku agregacji dla zagnieżdżonych dokumentów?

Dopóki Twoje dane mają unikalne odczyty czujników i znaczników na dokument, które do tej pory wydają się przedstawiane przez Ciebie, po prostu nie potrzebujesz $unwind w ogóle.
Tak naprawdę wszystko, czego naprawdę potrzebujesz, to jeden $group :
 db.endpoints.aggregate([
  // In reality you would $match to limit the selection of documents
  { "$match": { 
    "DateTime": { "$gte": new Date("2018-05-01"), "$lt": new Date("2018-06-01") }
  }},
  { "$group": {
    "_id": "$EndpointId",
    "FirstActivity" : { "$min" : "$DateTime" },
    "LastActivity" : { "$max" : "$DateTime" },
    "RequestCount": { "$sum": 1 },
    "TagCount": {
      "$sum": {
        "$size": { "$setUnion": ["$Tags.Uid",[]] }
      }
    },
    "SensorCount": {
      "$sum": {
        "$sum": {
          "$map": {
            "input": { "$setUnion": ["$Tags.Uid",[]] },
            "as": "tag",
            "in": {
              "$size": {
                "$reduce": {
                  "input": {
                    "$filter": {
                      "input": {
                        "$map": {
                          "input": "$Tags",
                          "in": {
                            "Uid": "$$this.Uid",
                            "Type": "$$this.Sensors.Type"
                          }
                        }
                      },
                      "cond": { "$eq": [ "$$this.Uid", "$$tag" ] }
                    }
                  },
                  "initialValue": [],
                  "in": { "$setUnion": [ "$$value", "$$this.Type" ] }
                }
              }
            }
          }
        }
      }
    }
  }}
])
 
 Lub jeśli rzeczywiście musisz zgromadzić te „unikalne” wartości „Czujniki” i „Tagi” z różnych dokumentów, nadal potrzebujesz początkowego $unwind 
 oświadczenia, aby uzyskać właściwe grupowanie, ale nie tak dużo, jak obecnie:
 db.endpoints.aggregate([
  // In reality you would $match to limit the selection of documents
  { "$match": { 
    "DateTime": { "$gte": new Date("2018-05-01"), "$lt": new Date("2018-06-01") }
  }},
  { "$unwind": "$Tags" },
  { "$unwind": "$Tags.Sensors" },
  { "$group": {
    "_id": {
      "EndpointId": "$EndpointId",
      "Uid": "$Tags.Uid",
      "Type": "$Tags.Sensors.Type"
    },
    "FirstActivity": { "$min": "$DateTime" },
    "LastActivity": { "$max": "$DateTime" },
    "RequestCount": { "$addToSet": "$_id" }
  }},
  { "$group": {
    "_id": {
      "EndpointId": "$_id.EndpointId",
      "Uid": "$_id.Uid",
    },
    "FirstActivity": { "$min": "$FirstActivity" },
    "LastActivity": { "$max": "$LastActivity" },
    "count": { "$sum": 1 },
    "RequestCount": { "$addToSet": "$RequestCount" }
  }},
  { "$group": {
    "_id": "$_id.EndpointId",
    "FirstActivity": { "$min": "$FirstActivity" },
    "LastActivity": { "$max": "$LastActivity" },
    "TagCount": { "$sum": 1 },
    "SensorCount": { "$sum": "$count" },
    "RequestCount": { "$addToSet": "$RequestCount" }
  }},
  { "$addFields": {
    "RequestCount": {
      "$size": {
        "$reduce": {
          "input": {
            "$reduce": {
              "input": "$RequestCount",
              "initialValue": [],
              "in": { "$setUnion": [ "$$value", "$$this" ] }
            }
          },
          "initialValue": [],
          "in": { "$setUnion": [ "$$value", "$$this" ] }
        }
      }
    }
  }}
],{ "allowDiskUse": true })
 
 A z MongoDB 4.0 możesz użyć $toString 
 na ObjectId w _id i po prostu połącz unikalne klucze dla tych, aby zachować RequestCount przy użyciu $mergeObjects 
 . Jest to czystsze i nieco bardziej skalowalne niż przesyłanie zawartości zagnieżdżonej tablicy i jej spłaszczanie
 db.endpoints.aggregate([
  // In reality you would $match to limit the selection of documents
  { "$match": { 
    "DateTime": { "$gte": new Date("2018-05-01"), "$lt": new Date("2018-06-01") }
  }},
  { "$unwind": "$Tags" },
  { "$unwind": "$Tags.Sensors" },
  { "$group": {
    "_id": {
      "EndpointId": "$EndpointId",
      "Uid": "$Tags.Uid",
      "Type": "$Tags.Sensors.Type"
    },
    "FirstActivity": { "$min": "$DateTime" },
    "LastActivity": { "$max": "$DateTime" },
    "RequestCount": {
      "$mergeObjects": {
        "$arrayToObject": [[{ "k": { "$toString": "$_id" }, "v": 1 }]]
      }
    }
  }},
  { "$group": {
    "_id": {
      "EndpointId": "$_id.EndpointId",
      "Uid": "$_id.Uid",
    },
    "FirstActivity": { "$min": "$FirstActivity" },
    "LastActivity": { "$max": "$LastActivity" },
    "count": { "$sum": 1 },
    "RequestCount": { "$mergeObjects": "$RequestCount" }
  }},
  { "$group": {
    "_id": "$_id.EndpointId",
    "FirstActivity": { "$min": "$FirstActivity" },
    "LastActivity": { "$max": "$LastActivity" },
    "TagCount": { "$sum": 1 },
    "SensorCount": { "$sum": "$count" },
    "RequestCount": { "$mergeObjects": "$RequestCount" }
  }},
  { "$addFields": {
    "RequestCount": {
      "$size": {
        "$objectToArray": "$RequestCount"
      }
    }
  }}
],{ "allowDiskUse": true })
 
 Każdy formularz zwraca te same dane, chociaż kolejność kluczy w wyniku może się różnić:
 {
        "_id" : "89799bcc-e86f-4c8a-b340-8b5ed53caf83",
        "FirstActivity" : ISODate("2018-05-06T19:05:02.666Z"),
        "LastActivity" : ISODate("2018-05-06T19:05:02.666Z"),
        "RequestCount" : 2,
        "TagCount" : 4,
        "SensorCount" : 16
}
 
 Wynik jest uzyskiwany z tych przykładowych dokumentów, które pierwotnie podałeś jako przykładowe źródło w pierwotnym pytaniu na ten temat 
 :
 {
    "_id" : ObjectId("5aef51dfaf42ea1b70d0c4db"),    
    "EndpointId" : "89799bcc-e86f-4c8a-b340-8b5ed53caf83",    
    "DateTime" : ISODate("2018-05-06T19:05:02.666Z"),
    "Url" : "test",
    "Tags" : [ 
        {
            "Uid" : "C1:3D:CA:D4:45:11",
            "Type" : 1,
            "DateTime" : ISODate("2018-05-06T19:05:02.666Z"),
            "Sensors" : [ 
                {
                    "Type" : 1,
                    "Value" : NumberDecimal("-95")
                }, 
                {
                    "Type" : 2,
                    "Value" : NumberDecimal("-59")
                }, 
                {
                    "Type" : 3,
                    "Value" : NumberDecimal("11.029802536740132")
                }, 
                {
                    "Type" : 4,
                    "Value" : NumberDecimal("27.25")
                }, 
                {
                    "Type" : 6,
                    "Value" : NumberDecimal("2924")
                }
            ]
        },         
        {
            "Uid" : "C1:3D:CA:D4:45:11",
            "Type" : 1,
            "DateTime" : ISODate("2018-05-06T19:05:02.666Z"),
            "Sensors" : [ 
                {
                    "Type" : 1,
                    "Value" : NumberDecimal("-95")
                }, 
                {
                    "Type" : 2,
                    "Value" : NumberDecimal("-59")
                }, 
                {
                    "Type" : 3,
                    "Value" : NumberDecimal("11.413037961112279")
                }, 
                {
                    "Type" : 4,
                    "Value" : NumberDecimal("27.25")
                }, 
                {
                    "Type" : 6,
                    "Value" : NumberDecimal("2924")
                }
            ]
        },          
        {
            "Uid" : "E5:FA:2A:35:AF:DD",
            "Type" : 1,
            "DateTime" : ISODate("2018-05-06T19:05:02.666Z"),
            "Sensors" : [ 
                {
                    "Type" : 1,
                    "Value" : NumberDecimal("-97")
                }, 
                {
                    "Type" : 2,
                    "Value" : NumberDecimal("-58")
                }, 
                {
                    "Type" : 3,
                    "Value" : NumberDecimal("10.171658037099185")
                }
            ]
        }
    ]
}

/* 2 */
{
    "_id" : ObjectId("5aef51e0af42ea1b70d0c4dc"),    
    "EndpointId" : "89799bcc-e86f-4c8a-b340-8b5ed53caf83",    
    "Url" : "test",
    "Tags" : [ 
        {
            "Uid" : "E2:02:00:18:DA:40",
            "Type" : 1,
            "DateTime" : ISODate("2018-05-06T19:05:04.574Z"),
            "Sensors" : [ 
                {
                    "Type" : 1,
                    "Value" : NumberDecimal("-98")
                }, 
                {
                    "Type" : 2,
                    "Value" : NumberDecimal("-65")
                }, 
                {
                    "Type" : 3,
                    "Value" : NumberDecimal("7.845424441900629")
                }, 
                {
                    "Type" : 4,
                    "Value" : NumberDecimal("0.0")
                }, 
                {
                    "Type" : 6,
                    "Value" : NumberDecimal("3012")
                }
            ]
        }, 
        {
            "Uid" : "12:3B:6A:1A:B7:F9",
            "Type" : 1,
            "DateTime" : ISODate("2018-05-06T19:05:04.574Z"),
            "Sensors" : [ 
                {
                    "Type" : 1,
                    "Value" : NumberDecimal("-95")
                }, 
                {
                    "Type" : 2,
                    "Value" : NumberDecimal("-59")
                }, 
                {
                    "Type" : 3,
                    "Value" : NumberDecimal("12.939770381907275")
                }
            ]
        }
    ]
}
 
 Konkluzja jest taka, że możesz użyć pierwszego podanego tutaj formularza, który będzie akumulowany „w każdym dokumencie”, a następnie „akumuluje się według punktu końcowego” w ramach jednego etapu i jest najbardziej optymalny, lub faktycznie musisz zidentyfikować takie rzeczy, jak  "Uid" na tagach lub "Typ" na czujniku, w którym te wartości występują więcej niż raz w dowolnej kombinacji dokumentów grupowanych według punktu końcowego.
 
 Twoje przykładowe dane dostarczone do tej pory pokazują tylko, że te wartości są „unikalne w każdym dokumencie”, dlatego pierwszy podany formularz byłby najbardziej optymalny, jeśli dotyczy to wszystkich pozostałych danych.
 
 Jeśli tak nie jest, jedynym sposobem podejścia do tego jest „rozwinięcie” dwóch zagnieżdżonych tablic w celu „agregacji szczegółów w dokumentach”. Możesz ograniczyć zakres dat lub inne kryteria, ponieważ większość „zapytań” zwykle ma pewne ograniczenia i nie działa na „całej” kolekcji danych, ale głównym faktem jest to, że tablice byłyby „rozwijane”, tworząc zasadniczo kopię dokumentu dla każdego element tablicy.
 
 Punkt dotyczący optymalizacji oznacza, że musisz to zrobić tylko "dwa razy", ponieważ są tylko dwie tablice. Wykonywanie kolejnych $group 
 do $unwind 
 do $group 
 to zawsze pewny znak, że robisz coś naprawdę złego. Po „rozłożeniu czegoś” wystarczy „złożyć to z powrotem” raz . W serii stopniowanych kroków, jak pokazano tutaj, jest raz podejście, które optymalizuje.
 
 Poza zakresem Twojego pytania nadal pozostaje:
  Dodaj inne realistyczne ograniczenia do zapytania, aby zmniejszyć liczbę przetwarzanych dokumentów, może nawet rób to w „partiach” i łącz wyniki
 Dodaj allowDiskUse opcja do rurociągu, aby umożliwić tymczasowe przechowywanie. (w rzeczywistości zademonstrowano na poleceniach)
 Zauważ, że „tablice zagnieżdżone” prawdopodobnie nie są najlepszą metodą przechowywania danych do analizy, którą chcesz przeprowadzić. Zawsze jest bardziej wydajny, gdy wiesz, że musisz $unwind 
 aby po prostu zapisać dane w tym „rozwiniętym” formularzu bezpośrednio do kolekcji.