Finden Sie in Doppelt Verschachtelten Array MongoDB

Im einfachsten Sinne dieser folgt gerade die grundlegende form der "dot-notation" wie MongoDB. Das funktioniert unabhängig davon, welches Arraymitglied die innere array-Mitglied ist, solange es passt den Wert:

db.mycollection.find({
    "someArray.someNestedArray.name": "value"
})

Dass ist in Ordnung für ein "einzelnes Feld" Wert, für den Abgleich mit mehreren Felder, die Sie verwenden würden,$elemMatch:

db.mycollection.find({
    "someArray": { 
        "$elemMatch": {
            "name": "name1",
            "someNestedArray": {
                "$elemMatch": {
                    "name": "value",
                    "otherField": 1
                }
            }
        }
    }
})

Entspricht das Dokument, das enthalten würde, was mit einem Feld an, dass "Pfad" entsprechen den Wert. Wenn Sie bestimmt sind zu "Spiel-und filter -" das Ergebnis also nur das passende element zurückgegeben wurde, dies ist nicht möglich, mit dem positionalen operator Projektion, wie zitiert:

Verschachtelte Arrays

Den Positionsparameter $ operator kann nicht für Abfragen verwendet werden, die traverse mehr als ein array, wie z.B. Abfragen, traverse verschachtelte arrays die in anderen arrays, da der Ersatz für die $ - Platzhalter ist ein einzelner Wert

Moderne MongoDB

Können wir tun dies, indem $filter und $anzeigen hier. Die $map ist unbedingt notwendig, da die "innere" array ändern kann, als ein Ergebnis von "filtern", und der "äußere" array natürlich nicht mit den Bedingungen, wenn das "innere" wurde gestrippt aller Elemente.

Wieder nach dem Beispiel tatsächlich mit mehreren Eigenschaften entsprechen, die innerhalb jedes array:

db.mycollection.aggregate([
  { "$match": {
    "someArray": {
      "$elemMatch": {
         "name": "name1",
         "someNestedArray": {
           "$elemMatch": {
             "name": "value",
             "otherField": 1
           }
         }
       }
    }
  }},
  { "$addFields": {
    "someArray": {
      "$filter": {
        "input": {
          "$map": {
            "input": "$someArray",
            "as": "sa",
            "in": {
              "name": "$$sa.name",
              "someNestedArray": {
                "$filter": {
                  "input": "$$sa.someNestedArray",
                  "as": "sn",
                  "cond": {
                    "$and": [
                      { "$eq": [ "$$sn.name", "value" ] },
                      { "$eq": [ "$$sn.otherField", 1 ] }
                    ]
                  }
                }
              }             
            }
          },
        },
        "as": "sa",
        "cond": {
          "$and": [
            { "$eq": [ "$$sa.name", "name1" ] },
            { "$gt": [ { "$size": "$$sa.someNestedArray" }, 0 ] }
          ]
        }
      }
    }
  }}
])

Daher auf die "äußere" array der $filter sieht eigentlich am $size der "inneren" array nach war es "gefiltert" selbst, so können Sie ablehnen, die Ergebnisse, wenn die ganze innere array in der Tat zu entsprechen, erwähnt zu werden.

Ältere MongoDB

Um "Projekt" nur das passende element, müssen Sie die .Summe() Methode:

db.mycollection.aggregate([
    //Match possible documents
    { "$match": {
        "someArray.someNestedArray.name": "value"
    }},

    //Unwind each array
    { "$unwind": "$someArray" },
    { "$unwind": "$someArray.someNestedArray" },

    //Filter just the matching elements
    { "$match": {
        "someArray.someNestedArray.name": "value"
    }},

    //Group to inner array
    { "$group": {
        "_id": { 
            "_id": "$_id", 
            "name": "$someArray.name"
        },
        "someKey": { "$first": "$someKey" },
        "someNestedArray": { "$push": "$someArray.someNestedArray" }
    }},

    //Group to outer array
    { "$group": {
        "_id": "$_id._id",
        "someKey": { "$first": "$someKey" },
        "someArray": { "$push": {
            "name": "$_id.name",
            "someNestedArray": "$someNestedArray"
        }}
    }} 
])

Können Sie auf "filter" die Spiele in verschachtelten arrays, die für eine oder mehrere Ergebnisse innerhalb des Dokuments.

InformationsquelleAutor Neil Lunn