Tìm bản ghi MongoDB nơi trường mảng không trống


502

Tất cả các hồ sơ của tôi có một lĩnh vực được gọi là "hình ảnh". Trường này là một chuỗi các chuỗi.

Bây giờ tôi muốn 10 bản ghi mới nhất trong đó mảng này KHÔNG trống.

Tôi đã đi vòng quanh, nhưng thật lạ là tôi không tìm thấy nhiều về điều này. Tôi đã đọc vào tùy chọn $ where, nhưng tôi đã tự hỏi mức độ chậm của các hàm riêng và liệu có một giải pháp tốt hơn.

Và thậm chí sau đó, điều đó không hoạt động:

ME.find({$where: 'this.pictures.length > 0'}).sort('-created').limit(10).execFind()

Trả về không có gì. Rời đi this.picturesmà không có bit chiều dài làm việc, nhưng sau đó nó cũng trả về các bản ghi trống, tất nhiên.

Câu trả lời:


828

Nếu bạn cũng có tài liệu không có khóa, bạn có thể sử dụng:

ME.find({ pictures: { $exists: true, $not: {$size: 0} } })

MongoDB không sử dụng các chỉ mục nếu kích thước $ có liên quan, vì vậy đây là một giải pháp tốt hơn:

ME.find({ pictures: { $exists: true, $ne: [] } })

Kể từ khi phát hành MongoDB 2.6, bạn có thể so sánh với toán tử $gtnhưng có thể dẫn đến kết quả không mong muốn (bạn có thể tìm thấy lời giải thích bị loại bỏ trong câu trả lời này ):

ME.find({ pictures: { $gt: [] } })

6
Đối với tôi đó là cách tiếp cận chính xác, vì nó đảm bảo mảng tồn tại và không trống.
LeandroCR

Làm cách nào tôi có thể đạt được chức năng tương tự bằng cách sử dụngmongoengine
Rohit Khatri

54
CẨN THẬN, ME.find({ pictures: { $gt: [] } })LÀ NGUY HIỂM, ngay cả trong các phiên bản MongoDB mới hơn. Nếu bạn có một chỉ mục trên trường danh sách của mình và chỉ mục đó được sử dụng trong quá trình truy vấn, bạn sẽ nhận được kết quả không mong muốn. Ví dụ: db.doc.find({'nums': { $gt: [] }}).hint({ _id: 1 }).count()trả về đúng số, trong khi db.doc.find({'nums': { $gt: [] }}).hint({ nums: 1 }).count()trả về 0.
wojcikstefan

1
Xem câu trả lời chi tiết của tôi dưới đây để tìm hiểu lý do tại sao điều này có thể không phù hợp với bạn: stackoverflow.com/a/42601244/1579058
wojcikstefan

6
Nhận xét của @ wojcikstefan cần được nâng cấp để ngăn mọi người sử dụng đề xuất cuối cùng, trong thực tế, trong một số trường hợp nhất định không trả lại tài liệu phù hợp.
Thomas Jung

181

Sau khi tìm kiếm thêm, đặc biệt là trong các tài liệu mongodb và các bit khó hiểu với nhau, đây là câu trả lời:

ME.find({pictures: {$exists: true, $not: {$size: 0}}})

27
Điều này không hoạt động. Tôi không biết nếu điều này trước đây hoạt động, nhưng điều này cũng sẽ trả về các đối tượng không có phím 'hình ảnh'.
Thứ

17
Không thể tin được làm thế nào câu trả lời này có 63 upvote, trong khi thực tế những gì @rdsoze nói là đúng - truy vấn cũng sẽ trả về các bản ghi khôngpicturestrường.
Dan Dascalescu

5
Hãy cẩn thận, mongoDB sẽ không sử dụng các chỉ mục nếu liên kết $ size có liên quan . Sẽ tốt hơn nếu bao gồm {$ ne: []} và có thể {$ ne: null}.
Levente Dobson

17
@rdsoze dòng đầu tiên của câu hỏi "Tất cả các bản ghi của tôi có một trường gọi là" hình ảnh ". Trường này là một mảng" . Hơn nữa, đây là một kịch bản hoàn toàn thực tế và phổ biến. Câu trả lời này không sai, nó hoạt động cho câu hỏi chính xác như được viết và chỉ trích hoặc hạ thấp nó vì thực tế là nó không giải quyết được một vấn đề khác là ngớ ngẩn.
Đánh dấu Amery

1
@Cec Tất cả các tài liệu nói rằng nếu bạn sử dụng $ size trong truy vấn, nó sẽ không sử dụng bất kỳ chỉ mục nào để cung cấp cho bạn kết quả nhanh hơn. Vì vậy, nếu bạn có một chỉ mục trên trường đó và bạn muốn sử dụng nó, hãy tuân theo các cách tiếp cận khác như {$ ne: []}, nếu điều đó phù hợp với bạn, điều đó sẽ sử dụng chỉ mục của bạn.
Levente Dobson

108

Điều này cũng có thể làm việc cho bạn:

ME.find({'pictures.0': {$exists: true}});

2
Đẹp! Điều này cũng cho phép bạn kiểm tra kích thước tối thiểu. Bạn có biết nếu các mảng luôn được lập chỉ mục tuần tự? Có bao giờ có trường hợp pictures.2tồn tại nhưng pictures.1không?
anushr

2
Các $existsnhà điều hành là một boolean, không phải là một bù đắp. @tenbatsu nên dùng truethay 1.
ekillaby

2
@anushr Would there ever be a case where pictures.2 exists but pictures.1 does not? Vâng, trường hợp đó có thể xảy ra.
Bndr

@TheBndr Điều đó chỉ có thể xảy ra nếu pictureslà một tài liệu con, không phải là một mảng. ví dụpictures: {'2': 123}
JohnnyHK

4
Điều này là tốt và trực quan, nhưng hãy cẩn thận nếu hiệu suất là quan trọng - nó sẽ thực hiện quét toàn bộ bộ sưu tập ngay cả khi bạn có chỉ mục trên pictures.
wojcikstefan

35

Bạn quan tâm đến hai điều khi truy vấn - độ chính xác và hiệu suất. Với ý nghĩ đó, tôi đã thử nghiệm một vài cách tiếp cận khác nhau trong MongoDB v3.0.14.

TL; DR db.doc.find({ nums: { $gt: -Infinity }})là nhanh nhất và đáng tin cậy nhất (ít nhất là trong phiên bản MongoDB mà tôi đã thử nghiệm).

EDIT: Điều này không còn hoạt động trong MongoDB v3.6! Xem các ý kiến ​​dưới bài viết này cho một giải pháp tiềm năng.

Thiết lập

Tôi đã chèn 1k tài liệu w / oa trường danh sách, 1k tài liệu với danh sách trống và 5 tài liệu với danh sách không trống.

for (var i = 0; i < 1000; i++) { db.doc.insert({}); }
for (var i = 0; i < 1000; i++) { db.doc.insert({ nums: [] }); }
for (var i = 0; i < 5; i++) { db.doc.insert({ nums: [1, 2, 3] }); }
db.doc.createIndex({ nums: 1 });

Tôi nhận ra điều này không đủ quy mô để thực hiện nghiêm túc như tôi trong các thử nghiệm dưới đây, nhưng nó đủ để trình bày tính chính xác của các truy vấn và hành vi khác nhau của các kế hoạch truy vấn đã chọn.

Xét nghiệm

db.doc.find({'nums': {'$exists': true}}) trả về kết quả sai (cho những gì chúng tôi đang cố gắng thực hiện).

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': {'$exists': true}}).count()
1005

-

db.doc.find({'nums.0': {'$exists': true}})trả về kết quả chính xác, nhưng nó cũng chậm khi sử dụng quét toàn bộ bộ sưu tập ( COLLSCANgiai đoạn thông báo trong phần giải thích).

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums.0': {'$exists': true}}).count()
5
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums.0': {'$exists': true}}).explain()
{
  "queryPlanner": {
    "plannerVersion": 1,
    "namespace": "test.doc",
    "indexFilterSet": false,
    "parsedQuery": {
      "nums.0": {
        "$exists": true
      }
    },
    "winningPlan": {
      "stage": "COLLSCAN",
      "filter": {
        "nums.0": {
          "$exists": true
        }
      },
      "direction": "forward"
    },
    "rejectedPlans": [ ]
  },
  "serverInfo": {
    "host": "MacBook-Pro",
    "port": 27017,
    "version": "3.0.14",
    "gitVersion": "08352afcca24bfc145240a0fac9d28b978ab77f3"
  },
  "ok": 1
}

-

db.doc.find({'nums': { $exists: true, $gt: { '$size': 0 }}})trả về kết quả sai. Đó là do quét chỉ mục không hợp lệ tiến tới không có tài liệu. Nó có thể sẽ chính xác nhưng chậm mà không có chỉ số.

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $gt: { '$size': 0 }}}).count()
0
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $gt: { '$size': 0 }}}).explain('executionStats').executionStats.executionStages
{
  "stage": "KEEP_MUTATIONS",
  "nReturned": 0,
  "executionTimeMillisEstimate": 0,
  "works": 2,
  "advanced": 0,
  "needTime": 0,
  "needFetch": 0,
  "saveState": 0,
  "restoreState": 0,
  "isEOF": 1,
  "invalidates": 0,
  "inputStage": {
    "stage": "FETCH",
    "filter": {
      "$and": [
        {
          "nums": {
            "$gt": {
              "$size": 0
            }
          }
        },
        {
          "nums": {
            "$exists": true
          }
        }
      ]
    },
    "nReturned": 0,
    "executionTimeMillisEstimate": 0,
    "works": 1,
    "advanced": 0,
    "needTime": 0,
    "needFetch": 0,
    "saveState": 0,
    "restoreState": 0,
    "isEOF": 1,
    "invalidates": 0,
    "docsExamined": 0,
    "alreadyHasObj": 0,
    "inputStage": {
      "stage": "IXSCAN",
      "nReturned": 0,
      "executionTimeMillisEstimate": 0,
      "works": 1,
      "advanced": 0,
      "needTime": 0,
      "needFetch": 0,
      "saveState": 0,
      "restoreState": 0,
      "isEOF": 1,
      "invalidates": 0,
      "keyPattern": {
        "nums": 1
      },
      "indexName": "nums_1",
      "isMultiKey": true,
      "direction": "forward",
      "indexBounds": {
        "nums": [
          "({ $size: 0.0 }, [])"
        ]
      },
      "keysExamined": 0,
      "dupsTested": 0,
      "dupsDropped": 0,
      "seenInvalidated": 0,
      "matchTested": 0
    }
  }
}

-

db.doc.find({'nums': { $exists: true, $not: { '$size': 0 }}})trả về kết quả chính xác, nhưng hiệu suất là xấu. Về mặt kỹ thuật, nó thực hiện quét chỉ mục, nhưng sau đó nó vẫn tiến bộ tất cả các tài liệu và sau đó phải lọc qua chúng).

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $not: { '$size': 0 }}}).count()
5
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $not: { '$size': 0 }}}).explain('executionStats').executionStats.executionStages
{
  "stage": "KEEP_MUTATIONS",
  "nReturned": 5,
  "executionTimeMillisEstimate": 0,
  "works": 2016,
  "advanced": 5,
  "needTime": 2010,
  "needFetch": 0,
  "saveState": 15,
  "restoreState": 15,
  "isEOF": 1,
  "invalidates": 0,
  "inputStage": {
    "stage": "FETCH",
    "filter": {
      "$and": [
        {
          "nums": {
            "$exists": true
          }
        },
        {
          "$not": {
            "nums": {
              "$size": 0
            }
          }
        }
      ]
    },
    "nReturned": 5,
    "executionTimeMillisEstimate": 0,
    "works": 2016,
    "advanced": 5,
    "needTime": 2010,
    "needFetch": 0,
    "saveState": 15,
    "restoreState": 15,
    "isEOF": 1,
    "invalidates": 0,
    "docsExamined": 2005,
    "alreadyHasObj": 0,
    "inputStage": {
      "stage": "IXSCAN",
      "nReturned": 2005,
      "executionTimeMillisEstimate": 0,
      "works": 2015,
      "advanced": 2005,
      "needTime": 10,
      "needFetch": 0,
      "saveState": 15,
      "restoreState": 15,
      "isEOF": 1,
      "invalidates": 0,
      "keyPattern": {
        "nums": 1
      },
      "indexName": "nums_1",
      "isMultiKey": true,
      "direction": "forward",
      "indexBounds": {
        "nums": [
          "[MinKey, MaxKey]"
        ]
      },
      "keysExamined": 2015,
      "dupsTested": 2015,
      "dupsDropped": 10,
      "seenInvalidated": 0,
      "matchTested": 0
    }
  }
}

-

db.doc.find({'nums': { $exists: true, $ne: [] }})trả về kết quả chính xác và nhanh hơn một chút, nhưng hiệu suất vẫn không lý tưởng. Nó sử dụng IXSCAN chỉ tiến bộ các tài liệu với trường danh sách hiện có, nhưng sau đó phải lọc ra từng danh sách trống.

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $ne: [] }}).count()
5
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $exists: true, $ne: [] }}).explain('executionStats').executionStats.executionStages
{
  "stage": "KEEP_MUTATIONS",
  "nReturned": 5,
  "executionTimeMillisEstimate": 0,
  "works": 1018,
  "advanced": 5,
  "needTime": 1011,
  "needFetch": 0,
  "saveState": 15,
  "restoreState": 15,
  "isEOF": 1,
  "invalidates": 0,
  "inputStage": {
    "stage": "FETCH",
    "filter": {
      "$and": [
        {
          "$not": {
            "nums": {
              "$eq": [ ]
            }
          }
        },
        {
          "nums": {
            "$exists": true
          }
        }
      ]
    },
    "nReturned": 5,
    "executionTimeMillisEstimate": 0,
    "works": 1017,
    "advanced": 5,
    "needTime": 1011,
    "needFetch": 0,
    "saveState": 15,
    "restoreState": 15,
    "isEOF": 1,
    "invalidates": 0,
    "docsExamined": 1005,
    "alreadyHasObj": 0,
    "inputStage": {
      "stage": "IXSCAN",
      "nReturned": 1005,
      "executionTimeMillisEstimate": 0,
      "works": 1016,
      "advanced": 1005,
      "needTime": 11,
      "needFetch": 0,
      "saveState": 15,
      "restoreState": 15,
      "isEOF": 1,
      "invalidates": 0,
      "keyPattern": {
        "nums": 1
      },
      "indexName": "nums_1",
      "isMultiKey": true,
      "direction": "forward",
      "indexBounds": {
        "nums": [
          "[MinKey, undefined)",
          "(undefined, [])",
          "([], MaxKey]"
        ]
      },
      "keysExamined": 1016,
      "dupsTested": 1015,
      "dupsDropped": 10,
      "seenInvalidated": 0,
      "matchTested": 0
    }
  }
}

-

db.doc.find({'nums': { $gt: [] }})LÀ NGUY HIỂM NGHIÊM TRỌNG TRÊN NỀN TẢNG ĐƯỢC SỬ DỤNG NÓ KẾT THÚC ĐỐI VỚI KẾT QUẢ. Đó là do quét chỉ mục không hợp lệ mà không có tài liệu.

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $gt: [] }}).count()
0
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $gt: [] }}).hint({ nums: 1 }).count()
0
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $gt: [] }}).hint({ _id: 1 }).count()
5

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $gt: [] }}).explain('executionStats').executionStats.executionStages
{
  "stage": "KEEP_MUTATIONS",
  "nReturned": 0,
  "executionTimeMillisEstimate": 0,
  "works": 1,
  "advanced": 0,
  "needTime": 0,
  "needFetch": 0,
  "saveState": 0,
  "restoreState": 0,
  "isEOF": 1,
  "invalidates": 0,
  "inputStage": {
    "stage": "FETCH",
    "filter": {
      "nums": {
        "$gt": [ ]
      }
    },
    "nReturned": 0,
    "executionTimeMillisEstimate": 0,
    "works": 1,
    "advanced": 0,
    "needTime": 0,
    "needFetch": 0,
    "saveState": 0,
    "restoreState": 0,
    "isEOF": 1,
    "invalidates": 0,
    "docsExamined": 0,
    "alreadyHasObj": 0,
    "inputStage": {
      "stage": "IXSCAN",
      "nReturned": 0,
      "executionTimeMillisEstimate": 0,
      "works": 1,
      "advanced": 0,
      "needTime": 0,
      "needFetch": 0,
      "saveState": 0,
      "restoreState": 0,
      "isEOF": 1,
      "invalidates": 0,
      "keyPattern": {
        "nums": 1
      },
      "indexName": "nums_1",
      "isMultiKey": true,
      "direction": "forward",
      "indexBounds": {
        "nums": [
          "([], BinData(0, ))"
        ]
      },
      "keysExamined": 0,
      "dupsTested": 0,
      "dupsDropped": 0,
      "seenInvalidated": 0,
      "matchTested": 0
    }
  }
}

-

db.doc.find({'nums.0’: { $gt: -Infinity }}) trả về kết quả chính xác, nhưng có hiệu suất kém (sử dụng quét toàn bộ bộ sưu tập).

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums.0': { $gt: -Infinity }}).count()
5
MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums.0': { $gt: -Infinity }}).explain('executionStats').executionStats.executionStages
{
  "stage": "COLLSCAN",
  "filter": {
    "nums.0": {
      "$gt": -Infinity
    }
  },
  "nReturned": 5,
  "executionTimeMillisEstimate": 0,
  "works": 2007,
  "advanced": 5,
  "needTime": 2001,
  "needFetch": 0,
  "saveState": 15,
  "restoreState": 15,
  "isEOF": 1,
  "invalidates": 0,
  "direction": "forward",
  "docsExamined": 2005
}

-

db.doc.find({'nums': { $gt: -Infinity }})đáng ngạc nhiên, điều này hoạt động rất tốt! Nó cho kết quả đúng và nhanh, tiến 5 tài liệu từ giai đoạn quét chỉ mục.

MacBook-Pro(mongod-3.0.14) test> db.doc.find({'nums': { $gt: -Infinity }}).explain('executionStats').executionStats.executionStages
{
  "stage": "FETCH",
  "nReturned": 5,
  "executionTimeMillisEstimate": 0,
  "works": 16,
  "advanced": 5,
  "needTime": 10,
  "needFetch": 0,
  "saveState": 0,
  "restoreState": 0,
  "isEOF": 1,
  "invalidates": 0,
  "docsExamined": 5,
  "alreadyHasObj": 0,
  "inputStage": {
    "stage": "IXSCAN",
    "nReturned": 5,
    "executionTimeMillisEstimate": 0,
    "works": 15,
    "advanced": 5,
    "needTime": 10,
    "needFetch": 0,
    "saveState": 0,
    "restoreState": 0,
    "isEOF": 1,
    "invalidates": 0,
    "keyPattern": {
      "nums": 1
    },
    "indexName": "nums_1",
    "isMultiKey": true,
    "direction": "forward",
    "indexBounds": {
      "nums": [
        "(-inf.0, inf.0]"
      ]
    },
    "keysExamined": 15,
    "dupsTested": 15,
    "dupsDropped": 10,
    "seenInvalidated": 0,
    "matchTested": 0
  }
}

Cảm ơn câu trả lời rất chi tiết của bạn @wojcikstefan. Thật không may, giải pháp đề xuất của bạn dường như không hoạt động trong trường hợp của tôi. Tôi có bộ sưu tập MongoDB 3.6.4 với 2m tài liệu, hầu hết trong số chúng có seen_eventsmảng String, cũng được lập chỉ mục. Tìm kiếm với { $gt: -Infinity }, tôi ngay lập tức nhận được 0 tài liệu. Sử dụng { $exists: true, $ne: [] }tôi nhận được nhiều tài liệu hơn 1,2 triệu, với rất nhiều thời gian bị lãng phí trong giai đoạn FETCH: gist.github.com/N-Coder/b9e89a925e895c605d84bfeed648d82c
NCode

Có vẻ như bạn @Ncode ngay đang - công trình này không còn trong MongoDB v3.6 :( Tôi chơi xung quanh với nó trong một vài phút và đây là những gì tôi thấy: 1. db.test_collection.find({"seen_events.0": {$exists: true}})là xấu vì nó sử dụng một bộ sưu tập quét 2.. db.test_collection.find({seen_events: {$exists: true, $ne: []}})Là xấu vì IXSCAN của nó khớp với tất cả các tài liệu và sau đó quá trình lọc được thực hiện trong giai đoạn FETCH chậm. 3. Tương tự như vậy db.test_collection.find({seen_events: {$exists: true, $not: {$size: 0}}}). 4. Tất cả các truy vấn khác trả về kết quả không hợp lệ.
wojcikstefan

1
@NCode đã tìm ra giải pháp! Nếu bạn chắc chắn rằng tất cả các seen_eventschuỗi không chứa rỗng , bạn có thể sử dụng : db.test_collection.find({seen_events: {$gt: ''}}).count(). Để xác nhận nó hoạt động tốt, hãy kiểm tra db.test_collection.find({seen_events: {$gt: ''}}).explain(true).executionStats. Bạn có thể thực thi rằng các sự kiện đã thấy là các chuỗi thông qua xác thực lược đồ: docs.mongodb.com/manual/core/schema-validation
wojcikstefan

Cảm ơn! Tất cả các giá trị hiện có là các chuỗi vì vậy tôi sẽ thử. Ngoài ra còn có một lỗi thảo luận về vấn đề này trong trình sửa lỗi MongoDB: jira.mongodb.org/browse/SERVER-26655
NCode

30

Bắt đầu với bản phát hành 2.6, một cách khác để làm điều này là so sánh trường với một mảng trống:

ME.find({pictures: {$gt: []}})

Kiểm tra nó trong vỏ:

> db.ME.insert([
{pictures: [1,2,3]},
{pictures: []},
{pictures: ['']},
{pictures: [0]},
{pictures: 1},
{foobar: 1}
])

> db.ME.find({pictures: {$gt: []}})
{ "_id": ObjectId("54d4d9ff96340090b6c1c4a7"), "pictures": [ 1, 2, 3 ] }
{ "_id": ObjectId("54d4d9ff96340090b6c1c4a9"), "pictures": [ "" ] }
{ "_id": ObjectId("54d4d9ff96340090b6c1c4aa"), "pictures": [ 0 ] }

Vì vậy, nó bao gồm đúng các tài liệu picturescó ít nhất một phần tử mảng và loại trừ các tài liệu trong đó pictureslà một mảng trống, không phải là một mảng hoặc thiếu.


7
CẨN THẬN câu trả lời này có thể gây rắc rối cho bạn nếu bạn cố gắng sử dụng các chỉ mục. Làm db.ME.createIndex({ pictures: 1 })và sau đó db.ME.find({pictures: {$gt: []}})sẽ trả về kết quả bằng không, ít nhất là trong MongoDB v3.0,14
wojcikstefan

@wojcikstefan Bắt tốt. Cần phải có một cái nhìn mới về điều này.
JohnnyHK

5

Bạn có thể sử dụng bất kỳ điều nào sau đây để đạt được điều này.
Cả hai cũng lưu ý không trả lại kết quả cho các đối tượng không có khóa được yêu cầu trong đó:

db.video.find({pictures: {$exists: true, $gt: {$size: 0}}})
db.video.find({comments: {$exists: true, $not: {$size: 0}}})

4

Truy xuất tất cả và chỉ các tài liệu trong đó 'hình ảnh' là một mảng và không trống

ME.find({pictures: {$type: 'array', $ne: []}})

Nếu sử dụng phiên bản MongoDb trước 3.2 , hãy sử dụng $type: 4thay vì $type: 'array'. Lưu ý rằng giải pháp này thậm chí không sử dụng kích thước $ , do đó, không có vấn đề gì với chỉ mục ("Truy vấn không thể sử dụng chỉ mục cho phần kích thước $ của truy vấn")

Các giải pháp khác, bao gồm cả những giải pháp này (câu trả lời được chấp nhận):

ME.find ({hình ảnh: {$ tồn tại: true, $ not: {$ size: 0}}}); ME.find ({hình ảnh: {$ tồn tại: đúng, $ ne: []}})

sai vì họ trả lại tài liệu ngay cả khi, ví dụ, 'hình ảnh' là null, undefined, 0, vv


2

Sử dụng $elemMatchtoán tử: theo tài liệu

Toán tử $ elemMatch khớp với các tài liệu chứa trường mảng có ít nhất một phần tử khớp với tất cả các tiêu chí truy vấn đã chỉ định.

$elemMatchesđảm bảo rằng giá trị là một mảng và nó không trống. Vì vậy, truy vấn sẽ là một cái gì đó như

ME.find({ pictures: { $elemMatch: {$exists: true }}})

PS Một biến thể của mã này được tìm thấy trong khóa học M121 của Đại học MongoDB.


0

Bạn cũng có thể sử dụng phương thức trợ giúp Tồn tại toán tử Mongo $ tồn tại

ME.find()
    .exists('pictures')
    .where('pictures').ne([])
    .sort('-created')
    .limit(10)
    .exec(function(err, results){
        ...
    });

0
{ $where: "this.pictures.length > 1" }

sử dụng $ where và truyền this.field_name.length, trả về kích thước của trường mảng và kiểm tra nó bằng cách so sánh với số. nếu bất kỳ mảng nào có giá trị lớn hơn kích thước mảng phải ít nhất là 1. vì vậy tất cả các trường mảng có độ dài nhiều hơn một, điều đó có nghĩa là nó có một số dữ liệu trong mảng đó


-8
ME.find({pictures: {$exists: true}}) 

Đơn giản như vậy, điều này làm việc cho tôi.

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.