L'agrégation de filtre après $recherche

La question ici est en fait quelque chose de différent et n'a pas besoin de $recherche à tous. Mais pour toute personne arrivant ici purement dans le titre de "filtrage après $recherche", alors ce sont les techniques pour vous:

MongoDB 3.6 - Sous-pipeline

db.test.aggregate([
    { "$match": { "id": 100 } },
    { "$lookup": {
      "from": "test",
      "let": { "id": "$id" },
      "pipeline": [
        { "$match": {
          "value": "1",
          "$expr": { "$in": [ "$$id", "$contain" ] }
        }}
      ],
      "as": "childs"
    }}
])

Plus tôt de dollars en recherche + $détendez-vous + $match coalescence

db.test.aggregate([
    { "$match": { "id": 100 } },
    { "$lookup": {
        "from": "test",
        "localField": "id",
        "foreignField": "contain",
        "as": "childs"
    }},
    { "$unwind": "$childs" },
    { "$match": { "childs.value": "1" } },
    { "$group": {
        "_id": "$_id",
        "id": { "$first": "$id" },
        "value": { "$first": "$value" },
        "contain": { "$first": "$contain" },
        "childs": { "$push": "$childs" }
     }}
])

Si vous la question, pourquoi voulez-vous $détendez-vous par opposition à l'aide $filter sur le tableau, puis lire Somme globale de recherche Total de la taille des documents dans la correspondance de pipeline dépasse la taille de document maximale pour tous les détails sur pourquoi cela est généralement nécessaire et bien plus optimale.

Pour les rejets de MongoDB, 3.6 et versions ultérieures, alors le plus expressif de "sous-pipeline" est généralement ce que vous voulez pour "filtrer" les résultats de la collecte à l'étranger avant toute chose revient dans le tableau.

Retour à la réponse, mais qui, en fait, explique pourquoi la question posée besoins "aucune jointure"....

---

Original

À l'aide de $recherche comme ce n'est pas la plus "efficace" façon de faire ce que vous voulez ici. Mais plus sur cela plus tard.

Comme un concept de base, il suffit d'utiliser $filter sur le tableau résultant:

db.test.aggregate([ 
    { "$match": { "id": 100 } }, 
    { "$lookup": {
        "from": "test",
        "localField": "id",
        "foreignField": "contain",
        "as": "childs"
    }},
    { "$project": {
        "id": 1,
        "value": 1,
        "contain": 1,
        "childs": {
           "$filter": {
               "input": "$childs",
               "as": "child",
               "cond": { "$eq": [ "$$child.value", "1" ] }
           }
        }
    }}
]);

Ou de l'utilisation $éditer à la place:

db.test.aggregate([ 
    { "$match": { "id": 100 } }, 
    { "$lookup": {
        "from": "test",
        "localField": "id",
        "foreignField": "contain",
        "as": "childs"
    }},
    { "$redact": {
        "$cond": {
           "if": {
              "$or": [
                { "$eq": [ "$value", "0" ] },
                { "$eq": [ "$value", "1" ] }
              ]
           },
           "then": "$$DESCEND",
           "else": "$$PRUNE"
        }
    }}
]);

À la fois obtenir le même résultat:

{  
  "_id":ObjectId("570557d4094a4514fc1291d6"),
  "id":100,
  "value":"0",
  "contain":[ ],
  "childs":[ {  
      "_id":ObjectId("570557d4094a4514fc1291d7"),
      "id":110,
      "value":"1",
      "contain":[ 100 ]
    },
    {  
      "_id":ObjectId("570557d4094a4514fc1291d8"),
      "id":120,
      "value":"1",
      "contain":[ 100 ]
    }
  ]
}

Ligne de fond est que $recherche lui-même ne peut pas "encore" requête pour sélectionner uniquement certaines données. Donc tous les "filtrage" qui doit arriver après la $recherche

Mais vraiment pour ce type d ' "auto-jointure" vous êtes mieux de ne pas utiliser $recherche à tous et d'éviter la surcharge d'un supplément de lire et de "hash-fusion" entièrement. Extraire seulement les éléments connexes et $group à la place:

db.test.aggregate([
  { "$match": { 
    "$or": [
      { "id": 100 },
      { "contain.0": 100, "value": "1" }
    ]
  }},
  { "$group": {
    "_id": {
      "$cond": {
        "if": { "$eq": [ "$value", "0" ] },
        "then": "$id",
        "else": { "$arrayElemAt": [ "$contain", 0 ] }
      }
    },
    "value": { "$first": { "$literal": "0"} },
    "childs": {
      "$push": {
        "$cond": {
          "if": { "$ne": [ "$value", "0" ] },
          "then": "$$ROOT",
          "else": null
        }
      }
    }
  }},
  { "$project": {
    "value": 1,
    "childs": {
      "$filter": {
        "input": "$childs",
        "as": "child",
        "cond": { "$ne": [ "$$child", null ] }
      }
    }
  }}
])

Qui vient seulement de sortir un peu différent parce que j'ai volontairement enlevé le superflu et de champs. Ajoutez-les à vous-même si vous voulez vraiment:

{
  "_id" : 100,
  "value" : "0",
  "childs" : [
    {
      "_id" : ObjectId("570557d4094a4514fc1291d7"),
      "id" : 110,
      "value" : "1",
      "contain" : [ 100 ]
    },
    {
      "_id" : ObjectId("570557d4094a4514fc1291d8"),
      "id" : 120,
      "value" : "1",
      "contain" : [ 100 ]
    }
  ]
}

Donc, la seule question ici est de "filtrage" tout null résultat de la matrice, créés lorsque le document actuel est la parent dans le traitement des éléments de $push.

---

Ce que vous semblez aussi manque ici, c'est que le résultat que vous recherchez n'a pas besoin d'agrégation ou de "sous-requêtes". La structure que vous avez conclu ou peut-être trouvé ailleurs est "conçu", de sorte que vous pouvez obtenir un "nœud" et tous ses "enfants" en une seule requête.

Cela signifie que la "requête" est tout ce qui est vraiment nécessaire, et la collecte de données ( qui est tout ce qui se passe car aucun contenu n'est vraiment "réduit" ) n'est qu'une fonction d'itération le curseur de résultat:

var result = {};

db.test.find({
  "$or": [
    { "id": 100 },
    { "contain.0": 100, "value": "1" }
  ]
}).sort({ "contain.0": 1 }).forEach(function(doc) {
  if ( doc.id == 100 ) {
    result = doc;
    result.childs = []
  } else {
    result.childs.push(doc)
  }
})

printjson(result);

Cela fait exactement la même chose:

{
  "_id" : ObjectId("570557d4094a4514fc1291d6"),
  "id" : 100,
  "value" : "0",
  "contain" : [ ],
  "childs" : [
    {
      "_id" : ObjectId("570557d4094a4514fc1291d7"),
      "id" : 110,
      "value" : "1",
      "contain" : [
              100
      ]
    },
    {
      "_id" : ObjectId("570557d4094a4514fc1291d8"),
      "id" : 120,
      "value" : "1",
      "contain" : [
              100
      ]
    }
  ]
}

Et sert de preuve que tout ce que vous devez faire ici est question de la "simple" requête pour sélectionner à la fois le parent et les enfants. Les données retournées sont les mêmes, et tout ce que vous faites soit sur le serveur ou le client est "massage" dans un autre recueillies format.

C'est l'un de ces cas où vous pouvez obtenir "capturé" dans la pensée de la façon dont on fait les choses dans une "relationnelle" de la base de données, sans se rendre compte que, depuis la façon dont les données sont stockées a "changé", vous n'avez plus besoin d'utiliser la même approche.

C'est exactement ce que le point de la documentation exemple "Arbre du Modèle des Structures de l'Enfant Références" dans sa structure, où il est facile de sélectionner les parents et les enfants dans une seule requête.

OriginalL'auteur Neil Lunn