Truy vấn tài liệu có kích thước mảng lớn hơn 1

Tôi có một bộ sưu tập MongoDB với các tài liệu ở định dạng sau:

{
  "_id" : ObjectId("4e8ae86d08101908e1000001"),
  "name" : ["Name"],
  "zipcode" : ["2223"]
}
{
  "_id" : ObjectId("4e8ae86d08101908e1000002"),
  "name" : ["Another ", "Name"],
  "zipcode" : ["2224"]
}

Hiện tại tôi có thể nhận tài liệu phù hợp với kích thước mảng cụ thể:

db.accommodations.find({ name : { $size : 2 }})

Điều này trả về chính xác các tài liệu với 2 phần tử trong namemảng. Tuy nhiên, tôi không thể thực hiện $gtlệnh trả về tất cả các tài liệu trong đó nametrường có kích thước mảng lớn hơn 2:

db.accommodations.find({ name : { $size: { $gt : 1 } }})

Làm cách nào tôi có thể chọn tất cả các tài liệu có một namemảng có kích thước lớn hơn một (tốt nhất là không phải sửa đổi cấu trúc dữ liệu hiện tại)?

Cập nhật:

Đối với phiên bản mongodb 2.2+ cách hiệu quả hơn để làm điều này được mô tả bởi @JohnnyHK trong một câu trả lời khác .

1.Sử dụng $ ở đâu

db.accommodations.find( { $where: "this.name.length > 1" } );

Nhưng...

Javascript thực thi chậm hơn các toán tử gốc được liệt kê trên trang này, nhưng rất linh hoạt. Xem trang xử lý phía máy chủ để biết thêm thông tin.

2. Tạo trường bổ sungNamesArrayLength , cập nhật nó với độ dài mảng tên và sau đó sử dụng trong các truy vấn:

db.accommodations.find({"NamesArrayLength": {$gt: 1} });

Nó sẽ là giải pháp tốt hơn, và sẽ hoạt động nhanh hơn nhiều (bạn có thể tạo chỉ mục trên đó).

Có một cách hiệu quả hơn để làm điều này trong MongoDB 2.2+ bây giờ là bạn có thể sử dụng các chỉ mục mảng số trong các khóa đối tượng truy vấn.

// Find all docs that have at least two name array elements.
db.accommodations.find({'name.1': {$exists: true}})

Bạn có thể hỗ trợ truy vấn này với một chỉ mục sử dụng biểu thức bộ lọc một phần (yêu cầu 3.2+):

// index for at least two name array elements
db.accommodations.createIndex(
    {'name.1': 1},
    {partialFilterExpression: {'name.1': {$exists: true}}}
);

Tôi tin rằng đây là truy vấn nhanh nhất trả lời câu hỏi của bạn, vì nó không sử dụng $wheremệnh đề diễn giải :

{$nor: [
    {name: {$exists: false}},
    {name: {$size: 0}},
    {name: {$size: 1}}
]}

Nó có nghĩa là "tất cả các tài liệu ngoại trừ những tài liệu không có tên (không tồn tại hoặc mảng trống) hoặc chỉ có một tên."

Kiểm tra:

> db.test.save({})
> db.test.save({name: []})
> db.test.save({name: ['George']})
> db.test.save({name: ['George', 'Raymond']})
> db.test.save({name: ['George', 'Raymond', 'Richard']})
> db.test.save({name: ['George', 'Raymond', 'Richard', 'Martin']})
> db.test.find({$nor: [{name: {$exists: false}}, {name: {$size: 0}}, {name: {$size: 1}}]})
{ "_id" : ObjectId("511907e3fb13145a3d2e225b"), "name" : [ "George", "Raymond" ] }
{ "_id" : ObjectId("511907e3fb13145a3d2e225c"), "name" : [ "George", "Raymond", "Richard" ] }
{ "_id" : ObjectId("511907e3fb13145a3d2e225d"), "name" : [ "George", "Raymond", "Richard", "Martin" ] }
>

Bạn cũng có thể sử dụng tổng hợp:

db.accommodations.aggregate(
[
     {$project: {_id:1, name:1, zipcode:1, 
                 size_of_name: {$size: "$name"}
                }
     },
     {$match: {"size_of_name": {$gt: 1}}}
])

// bạn thêm "size_of_name" vào tài liệu chuyển tuyến và sử dụng nó để lọc kích thước của tên

Hãy thử làm một cái gì đó như thế này:

db.getCollection('collectionName').find({'ArrayName.1': {$exists: true}})

1 là số, nếu bạn muốn tìm nạp bản ghi lớn hơn 50 thì hãy thực hiện ArrayName.50 Cảm ơn.

Không ai ở trên làm việc cho tôi. Điều này đã làm như vậy tôi đang chia sẻ nó:

db.collection.find( {arrayName : {$exists:true}, $where:'this.arrayName.length>1'} )

Bạn có thể sử dụng $ expr (toán tử phiên bản 3.6 mongo) để sử dụng các hàm tổng hợp trong truy vấn thông thường.

So sánh query operatorsvới aggregation comparison operators.

db.accommodations.find({$expr:{$gt:[{$size:"$name"}, 1]}})

db.accommodations.find({"name":{"$exists":true, "$ne":[], "$not":{"$size":1}}})

MongoDB 3.6 bao gồm $ expr https://docs.mongodb.com/manual/reference/operator/query/expr/

Bạn có thể sử dụng $ expr để đánh giá biểu thức bên trong khớp $ hoặc tìm.

{ $match: {
           $expr: {$gt: [{$size: "$yourArrayField"}, 0]}
         }
}

hoặc tìm

collection.find({$expr: {$gte: [{$size: "$yourArrayField"}, 0]}});

Tôi đã tìm thấy giải pháp này, để tìm các mục có trường mảng lớn hơn độ dài nhất định

db.allusers.aggregate([
  {$match:{username:{$exists:true}}},
  {$project: { count: { $size:"$locations.lat" }}},
  {$match:{count:{$gt:20}}}
])

Tổng hợp $ khớp đầu tiên sử dụng một đối số đúng với tất cả các tài liệu. Nếu trống, tôi sẽ nhận được

"errmsg" : "exception: The argument to $size must be an Array, but was of type: EOO"

Tôi biết câu hỏi cũ của nó, nhưng tôi đang thử câu hỏi này với $ gte và $ size tìm thấy. Tôi nghĩ rằng để tìm () là nhanh hơn.

db.getCollection('collectionName').find({ name : { $gte : {  $size : 1 } }})

Mặc dù tất cả các câu trả lời ở trên đều hoạt động, những gì ban đầu bạn cố gắng làm là cách chính xác, tuy nhiên bạn chỉ cần có cú pháp ngược (chuyển đổi "$ size" và "$ gt") ..

Chính xác:

db.collection.find({items: {$gt: {$size: 1}}})

Sai:

db.collection.find({items: {$size: {$gt: 1}}})