Chỉ truy xuất phần tử được truy vấn trong một mảng đối tượng trong bộ sưu tập MongoDB

Giả sử bạn có các tài liệu sau trong bộ sưu tập của tôi:

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

Làm truy vấn:

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

Hoặc là

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

Trả về tài liệu trùng khớp (Tài liệu 1) , nhưng luôn có TẤT CẢ các mục trong shapes:

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

Tuy nhiên, tôi chỉ muốn lấy tài liệu (Tài liệu 1) với mảng chứa color=red:

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

Tôi có thể làm cái này như thế nào?

$elemMatchToán tử trình chiếu mới của MongoDB 2.2 cung cấp một cách khác để thay đổi tài liệu được trả về để chỉ chứa phần tử được khớp đầu tiênshapes :

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

Trả về:

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

Trong 2.2, bạn cũng có thể thực hiện việc này bằng cách sử dụng $ projection operator, trong đó $tên trường đối tượng chiếu đại diện cho chỉ mục của phần tử mảng phù hợp đầu tiên của trường từ truy vấn. Sau đây trả về kết quả tương tự như trên:

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

Cập nhật MongoDB 3.2

Bắt đầu với phiên bản 3.2, bạn có thể sử dụng $filtertoán tử tổng hợp mới để lọc một mảng trong khi chiếu, có lợi ích bao gồm tất cả các kết quả khớp, thay vì chỉ một đầu tiên.

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

Các kết quả:

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

Khung kết hợp mới trong MongoDB 2.2+ cung cấp một giải pháp thay thế cho Bản đồ / Thu nhỏ. Các $unwindnhà điều hành có thể được sử dụng để tách bạn shapesmảng vào một dòng của tài liệu có thể được xuất hiện:

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

Kết quả trong:

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

Một cách xen kẽ khác là sử dụng $ redact , đây là một trong những tính năng tổng hợp mới của MongoDB 2.6 . Nếu bạn đang sử dụng 2.6, bạn không cần $ relax có thể gây ra vấn đề về hiệu suất nếu bạn có mảng lớn.

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

$redact "Hạn chế nội dung của các tài liệu dựa trên thông tin được lưu trữ trong chính tài liệu đó" . Vì vậy, nó sẽ chỉ chạy bên trong tài liệu . Về cơ bản, nó quét tài liệu của bạn từ trên xuống dưới và kiểm tra xem nó có khớp với ifđiều kiện của bạn không $cond, nếu có trùng khớp, nó sẽ giữ nội dung ( $$DESCEND) hoặc remove ( $$PRUNE).

Trong ví dụ trên, đầu tiên $matchtrả về toàn bộ shapesmảng và $ redact đưa nó xuống kết quả mong đợi.

Lưu ý rằng điều đó {$not:"$color"}là cần thiết, bởi vì nó cũng sẽ quét tài liệu hàng đầu và nếu $redactkhông tìm thấy một colortrường ở cấp cao nhất, điều này sẽ trả về falsecó thể tước toàn bộ tài liệu mà chúng tôi không muốn.

Thận trọng: Câu trả lời này cung cấp một giải pháp có liên quan tại thời điểm đó , trước khi các tính năng mới của MongoDB 2.2 trở lên được giới thiệu. Xem các câu trả lời khác nếu bạn đang sử dụng phiên bản MongoDB mới hơn.

Tham số bộ chọn trường được giới hạn ở các thuộc tính hoàn chỉnh. Nó không thể được sử dụng để chọn một phần của một mảng, chỉ toàn bộ mảng. Tôi đã thử sử dụng toán tử vị trí $ , nhưng nó không hoạt động.

Cách dễ nhất là chỉ lọc các hình dạng trong máy khách .

Nếu bạn thực sự cần đầu ra chính xác trực tiếp từ MongoDB, bạn có thể sử dụng bản đồ thu nhỏ để lọc các hình dạng.

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

Tốt hơn là bạn có thể truy vấn trong phần tử mảng phù hợp bằng cách sử dụng $sliceđể trả về đối tượng quan trọng trong một mảng.

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

$slicelà hữu ích khi bạn biết chỉ số của phần tử, nhưng đôi khi bạn muốn phần tử mảng nào phù hợp với tiêu chí của bạn. Bạn có thể trả về phần tử phù hợp với $toán tử.

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

NGOÀI RA

{

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

Cú pháp tìm trong mongodb là

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

và truy vấn thứ hai mà bạn đã viết, đó là

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

trong phần này bạn đã sử dụng $elemMatchtoán tử trong phần truy vấn, trong khi nếu bạn sử dụng toán tử này trong phần chiếu thì bạn sẽ nhận được kết quả mong muốn. Bạn có thể viết ra truy vấn của bạn như

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

Điều này sẽ cung cấp cho bạn kết quả mong muốn.

Cảm ơn JohnnyHK .

Ở đây tôi chỉ muốn thêm một số cách sử dụng phức tạp hơn.

// 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"
    }
]}

Bạn chỉ cần chạy truy vấn

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

đầu ra của truy vấn này là

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

như bạn mong đợi, nó sẽ cung cấp trường chính xác từ mảng khớp với màu: 'đỏ'.

cùng với dự án $, các yếu tố kết hợp khôn ngoan khác sẽ phù hợp hơn với các yếu tố khác trong tài liệu.

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

Tương tự như vậy, bạn có thể tìm thấy cho nhiều

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

Sử dụng hàm tổng hợp và $projectđể có được trường đối tượng cụ thể trong tài liệu

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

kết quả:

{
    "_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")
        }
    ]
}

Mặc dù câu hỏi đã được hỏi 9,6 năm trước, nhưng điều này đã giúp ích rất nhiều cho nhiều người, tôi là một trong số họ. Cảm ơn tất cả mọi người cho tất cả các truy vấn, gợi ý và câu trả lời của bạn. Chọn từ một trong những câu trả lời ở đây .. Tôi thấy rằng phương pháp sau đây cũng có thể được sử dụng để chiếu các trường khác trong tài liệu gốc. Điều này có thể hữu ích cho ai đó.

Đối với tài liệu sau đây, cần phải tìm hiểu xem một nhân viên (emp # 7839) có lịch sử nghỉ phép của anh ta cho năm 2020 hay không. Lịch sử nghỉ phép được thực hiện như một tài liệu nhúng trong tài liệu Nhân viên chính.

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