Rufen Sie nur das abgefragte Element in einem Objektarray in der MongoDB-Auflistung ab

Angenommen, Sie haben die folgenden Dokumente in meiner Sammlung:

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

Fragen Sie ab:

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

Oder

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

Gibt übereinstimmendes Dokument (Dokument 1) zurück , jedoch immer mit ALLEN Array-Elementen in shapes:

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

Ich möchte das Dokument (Dokument 1) jedoch nur mit dem Array erhalten, das Folgendes enthält color=red:

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

Wie kann ich das machen?

Der neue $elemMatchProjektionsoperator von MongoDB 2.2 bietet eine weitere Möglichkeit, das zurückgegebene Dokument so zu ändern, dass es nur das erste übereinstimmende shapesElement enthält:

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

Kehrt zurück:

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

In 2.2 können Sie auch das tun dies mit $ projection operator, in dem die $in einem Projektionsobjekt Feldnamen den Index des ersten Anpassungs Feldelementes Feld repräsentiert aus der Abfrage. Das Folgende liefert die gleichen Ergebnisse wie oben:

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

MongoDB 3.2 Update

Ab Version 3.2 können Sie den neuen $filterAggregationsoperator verwenden, um ein Array während der Projektion zu filtern. Dies hat den Vorteil, dass alle Übereinstimmungen anstelle nur der ersten berücksichtigt werden.

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
    }}
])

Ergebnisse:

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

Das neue Aggregation Framework in MongoDB 2.2+ bietet eine Alternative zu Map / Reduce. Mit dem $unwindOperator können Sie Ihr shapesArray in einen Stream von Dokumenten aufteilen, die abgeglichen werden können:

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"
  }}
)

Ergebnisse in:

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

Eine andere interessante Möglichkeit ist die Verwendung von $ redact , einer der neuen Aggregationsfunktionen von MongoDB 2.6 . Wenn Sie 2.6 verwenden, benötigen Sie kein $ unwind, was bei großen Arrays zu Leistungsproblemen führen kann.

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

$redact "schränkt den Inhalt der Dokumente auf der Grundlage der in den Dokumenten selbst gespeicherten Informationen ein" . Es wird also nur innerhalb des Dokuments ausgeführt . Grundsätzlich wird Ihr Dokument von oben nach unten gescannt und überprüft, ob es mit Ihrer aktuellen ifBedingung übereinstimmt. Wenn eine Übereinstimmung vorliegt $cond, wird entweder der Inhalt beibehalten ( $$DESCEND) oder entfernt ( $$PRUNE).

Im obigen Beispiel wird zuerst $matchdas gesamte shapesArray zurückgegeben, und $ redact reduziert es auf das erwartete Ergebnis.

Beachten Sie, dass dies {$not:"$color"}erforderlich ist, da auch das oberste Dokument gescannt wird. Wenn auf der obersten Ebene $redactkein colorFeld gefunden wird false, wird möglicherweise das gesamte Dokument entfernt, das wir nicht möchten.

Achtung: Diese Antwort bietet eine Lösung, die zu diesem Zeitpunkt relevant war , bevor die neuen Funktionen von MongoDB 2.2 und höher eingeführt wurden. Weitere Antworten finden Sie, wenn Sie eine neuere Version von MongoDB verwenden.

Der Feldauswahlparameter ist auf vollständige Eigenschaften beschränkt. Es kann nicht verwendet werden, um einen Teil eines Arrays auszuwählen, sondern nur das gesamte Array. Ich habe versucht, den $ positional-Operator zu verwenden , aber das hat nicht funktioniert.

Am einfachsten ist es, nur die Formen im Client zu filtern .

Wenn Sie wirklich die richtige Ausgabe direkt von MongoDB benötigen , können Sie die Formen mithilfe einer Kartenreduzierung filtern.

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()

Besser ist es, wenn Sie das passende Array-Element abfragen, indem $sliceSie das signifikante Objekt in einem Array zurückgeben.

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

$sliceist hilfreich, wenn Sie den Index des Elements kennen, aber manchmal möchten Sie, dass das Array-Element Ihren Kriterien entspricht. Sie können das übereinstimmende Element mit dem $Operator zurückgeben.

 db.getCollection('aj').find({"shapes.color":"red"},{"shapes.$":1})

AUSGÄNGE

{

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

Die Syntax für find in mongodb lautet

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

und die zweite Abfrage, die Sie geschrieben haben, das heißt

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

In diesem Fall haben Sie den $elemMatchOperator im Abfrageteil verwendet. Wenn Sie diesen Operator im Projektionsteil verwenden, erhalten Sie das gewünschte Ergebnis. Sie können Ihre Anfrage als aufschreiben

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

Dadurch erhalten Sie das gewünschte Ergebnis.

Vielen Dank an JohnnyHK .

Hier möchte ich nur eine komplexere Verwendung hinzufügen.

// Document 
{ 
"_id" : 1
"shapes" : [
  {"shape" : "square",  "color" : "red"},
  {"shape" : "circle",  "color" : "green"}
  ] 
} 

{ 
"_id" : 2
"shapes" : [
  {"shape" : "square",  "color" : "red"},
  {"shape" : "circle",  "color" : "green"}
  ] 
} 


// The Query   
db.contents.find({
    "_id" : ObjectId(1),
    "shapes.color":"red"
},{
    "_id": 0,
    "shapes" :{
       "$elemMatch":{
           "color" : "red"
       } 
    }
}) 


//And the Result

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

Sie müssen nur die Abfrage ausführen

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

Ausgabe dieser Abfrage ist

{
    "_id" : ObjectId("562e7c594c12942f08fe4192"),
    "shapes" : [ 
        {"shape" : "circle", "color" : "red"}
    ]
}

Wie erwartet wird das genaue Feld des Arrays angezeigt, das der Farbe entspricht: 'rot'.

zusammen mit $ project ist es angemessener, andere weise übereinstimmende Elemente zusammen mit anderen Elementen im Dokument zu kombinieren.

db.test.aggregate(
  { "$unwind" : "$shapes" },
  { "$match" : {
     "shapes.color": "red"
  }},
{"$project":{
"_id":1,
"item":1
}}
)

Ebenso können Sie für das Vielfache finden

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

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

Verwenden Sie die Aggregationsfunktion und $project, um ein bestimmtes Objektfeld im Dokument abzurufen

db.getCollection('geolocations').aggregate([ { $project : { geolocation : 1} } ])

Ergebnis:

{
    "_id" : ObjectId("5e3ee15968879c0d5942464b"),
    "geolocation" : [ 
        {
            "_id" : ObjectId("5e3ee3ee68879c0d5942465e"),
            "latitude" : 12.9718313,
            "longitude" : 77.593551,
            "country" : "India",
            "city" : "Chennai",
            "zipcode" : "560001",
            "streetName" : "Sidney Road",
            "countryCode" : "in",
            "ip" : "116.75.115.248",
            "date" : ISODate("2020-02-08T16:38:06.584Z")
        }
    ]
}

Obwohl die Frage vor 9,6 Jahren gestellt wurde, war dies für zahlreiche Menschen, von denen ich einer von ihnen bin, eine immense Hilfe. Vielen Dank an alle für all Ihre Fragen, Hinweise und Antworten. Ich habe festgestellt, dass die folgende Methode auch zum Projizieren anderer Felder im übergeordneten Dokument verwendet werden kann. Dies kann für jemanden hilfreich sein.

Für das folgende Dokument musste herausgefunden werden, ob für einen Mitarbeiter (emp # 7839) die Urlaubshistorie für das Jahr 2020 festgelegt wurde. Die Urlaubshistorie wird als eingebettetes Dokument im übergeordneten Mitarbeiterdokument implementiert.

db.employees.find( {"leave_history.calendar_year": 2020}, 
    {leave_history: {$elemMatch: {calendar_year: 2020}},empno:true,ename:true}).pretty()


{
        "_id" : ObjectId("5e907ad23997181dde06e8fc"),
        "empno" : 7839,
        "ename" : "KING",
        "mgrno" : 0,
        "hiredate" : "1990-05-09",
        "sal" : 100000,
        "deptno" : {
                "_id" : ObjectId("5e9065f53997181dde06e8f8")
        },
        "username" : "none",
        "password" : "none",
        "is_admin" : "N",
        "is_approver" : "Y",
        "is_manager" : "Y",
        "user_role" : "AP",
        "admin_approval_received" : "Y",
        "active" : "Y",
        "created_date" : "2020-04-10",
        "updated_date" : "2020-04-10",
        "application_usage_log" : [
                {
                        "logged_in_as" : "AP",
                        "log_in_date" : "2020-04-10"
                },
                {
                        "logged_in_as" : "EM",
                        "log_in_date" : ISODate("2020-04-16T07:28:11.959Z")
                }
        ],
        "leave_history" : [
                {
                        "calendar_year" : 2020,
                        "pl_used" : 0,
                        "cl_used" : 0,
                        "sl_used" : 0
                },
                {
                        "calendar_year" : 2021,
                        "pl_used" : 0,
                        "cl_used" : 0,
                        "sl_used" : 0
                }
        ]
}