Récupérer uniquement l'élément interrogé dans un tableau d'objets dans une collection MongoDB.

Question

Supposons que vous ayez les documents suivants dans ma collection :

{  
   "_id":ObjectId("562e7c594c12942f08fe4192"),
   "shapes":[  
      {  
         "shape":"square",
         "color":"blue"
      },
      {  
         "shape":"circle",
         "color":"red"
      }
   ]
},
{  
   "_id":ObjectId("562e7c594c12942f08fe4193"),
   "shapes":[  
      {  
         "shape":"square",
         "color":"black"
      },
      {  
         "shape":"circle",
         "color":"green"
      }
   ]
}

---

Faites des requêtes :

db.test.find({"shapes.color": "red"}, {"shapes.color": 1})

Ou

db.test.find({shapes: {"$elemMatch": {color: "red"}}}, {"shapes.color": 1})

---

Retourne le document correspondant (Document 1) mais toujours avec TOUS les éléments du tableau dans shapes :

{ "shapes": 
  [
    {"shape": "square", "color": "blue"},
    {"shape": "circle", "color": "red"}
  ] 
}

Cependant, j'aimerais obtenir le document (Document 1) uniquement avec le tableau qui contient color=red :

{ "shapes": 
  [
    {"shape": "circle", "color": "red"}
  ] 
}

Comment puis-je le faire ?

Answer 1

Les nouveautés de MongoDB 2.2 $elemMatch fournit un autre moyen de modifier le document retourné pour qu'il ne contienne que les éléments suivants premièrement jumelé shapes élément :

db.test.find(
    {"shapes.color": "red"}, 
    {_id: 0, shapes: {$elemMatch: {color: "red"}}});

Les retours :

{"shapes" : [{"shape": "circle", "color": "red"}]}

Dans la version 2.2, vous pouvez également le faire en utilisant la fonction $ projection operator où le $ dans le nom du champ d'un objet de projection représente l'index du premier élément de tableau correspondant de la requête. L'exemple suivant renvoie les mêmes résultats que ci-dessus :

db.test.find({"shapes.color": "red"}, {_id: 0, 'shapes.$': 1});

Mise à jour de MongoDB 3.2

À partir de la version 3.2, vous pouvez utiliser la nouvelle fonction $filter opérateur d'agrégation pour filtrer un tableau lors de la projection, ce qui a pour avantage d'inclure todo au lieu de la première.

db.test.aggregate([
    // Get just the docs that contain a shapes element where color is 'red'
    {$match: {'shapes.color': 'red'}},
    {$project: {
        shapes: {$filter: {
            input: '$shapes',
            as: 'shape',
            cond: {$eq: ['$$shape.color', 'red']}
        }},
        _id: 0
    }}
])

Résultats :

[ 
    {
        "shapes" : [ 
            {
                "shape" : "circle",
                "color" : "red"
            }
        ]
    }
]

Answer 2

Le nouveau Cadre d'agrégation dans MongoDB 2.2+ offre une alternative à Map/Reduce. Le site $unwind peut être utilisé pour séparer votre shapes en un flux de documents qui peuvent être mis en correspondance :

db.test.aggregate(
  // Start with a $match pipeline which can take advantage of an index and limit documents processed
  { $match : {
     "shapes.color": "red"
  }},
  { $unwind : "$shapes" },
  { $match : {
     "shapes.color": "red"
  }}
)

Résultats dans :

{
    "result" : [
        {
            "_id" : ObjectId("504425059b7c9fa7ec92beec"),
            "shapes" : {
                "shape" : "circle",
                "color" : "red"
            }
        }
    ],
    "ok" : 1
}

Answer 3

Attention : Cette réponse fournit une solution qui était pertinente à cette époque avant l'introduction des nouvelles fonctionnalités de MongoDB 2.2 et plus. Consultez les autres réponses si vous utilisez une version plus récente de MongoDB.

Le paramètre du sélecteur de champ est limité aux propriétés complètes. Il ne peut pas être utilisé pour sélectionner une partie d'un tableau, mais uniquement l'ensemble du tableau. J'ai essayé d'utiliser le paramètre $ opérateur positionnel mais ça n'a pas marché.

La méthode la plus simple consiste à filtrer les formes. dans le client .

Si vous voulez vraiment besoin de la sortie correcte directement de MongoDB, vous pouvez utiliser un map-reduce pour filtrer les formes.

function map() {
  filteredShapes = [];

  this.shapes.forEach(function (s) {
    if (s.color === "red") {
      filteredShapes.push(s);
    }
  });

  emit(this._id, { shapes: filteredShapes });
}

function reduce(key, values) {
  return values[0];
}

res = db.test.mapReduce(map, reduce, { query: { "shapes.color": "red" } })

db[res.result].find()

Answer 4

Un autre moyen intéressant est d'utiliser $redact qui est l'une des nouvelles fonctions d'agrégation de l'UE. MongoDB 2.6 . Si vous utilisez la version 2.6, vous n'avez pas besoin d'un $unwind qui pourrait vous causer des problèmes de performance si vous avez de grands tableaux.

db.test.aggregate([
    { $match: { 
         shapes: { $elemMatch: {color: "red"} } 
    }},
    { $redact : {
         $cond: {
             if: { $or : [{ $eq: ["$color","red"] }, { $not : "$color" }]},
             then: "$$DESCEND",
             else: "$$PRUNE"
         }
    }}]);

$redact "restreint le contenu des documents sur la base des informations stockées dans les documents eux-mêmes". . Ainsi, il ne fonctionnera que à l'intérieur du document . Il numérise votre document de haut en bas, et vérifie s'il correspond à votre logo. if qui est en $cond s'il y a une correspondance, il conservera le contenu ( $$DESCEND ) ou remove( $$PRUNE ).

Dans l'exemple ci-dessus, on commence par $match retourne l'ensemble du shapes et $redact le réduit au résultat attendu.

Notez que {$not:"$color"} est nécessaire, car il numérisera également le document supérieur, et si $redact ne trouve pas de color au niveau supérieur, cela donnera false qui pourrait dépouiller le document entier, ce que nous ne voulons pas.

Answer 5

La syntaxe de find dans mongodb est la suivante

    db.<collection name>.find(query, projection);

et la deuxième requête que vous avez écrite, c'est-à-dire

    db.test.find(
    {shapes: {"$elemMatch": {color: "red"}}}, 
    {"shapes.color":1})

dans ce cas, vous avez utilisé le $elemMatch dans la partie requête, alors que si vous utilisez cet opérateur dans la partie projection, vous obtiendrez le résultat souhaité. Vous pouvez écrire votre requête comme suit

     db.users.find(
     {"shapes.color":"red"},
     {_id:0, shapes: {$elemMatch : {color: "red"}}})

Vous obtiendrez ainsi le résultat souhaité.