Temukan catatan MongoDB di mana bidang array tidak kosong

503

Semua catatan saya memiliki bidang yang disebut "gambar". Bidang ini adalah larik string.

Saya sekarang ingin 10 catatan terbaru di mana array ini TIDAK kosong.

Saya sudah googled sekitar, tapi anehnya saya belum menemukan banyak tentang ini. Saya sudah membaca opsi $ where, tapi saya bertanya-tanya seberapa lambat itu untuk fungsi asli, dan jika ada solusi yang lebih baik.

Dan bahkan kemudian, itu tidak berhasil:

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

Tidak menghasilkan apa-apa. Meninggalkan this.picturestanpa panjang bit tidak berfungsi, tetapi kemudian juga mengembalikan catatan kosong, tentu saja.

mongodb  mongoose 
— skerit
sumber

Jawaban:

831

Jika Anda juga memiliki dokumen yang tidak memiliki kunci, Anda dapat menggunakan:

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

MongoDB tidak menggunakan indeks jika $ size terlibat, jadi di sini adalah solusi yang lebih baik:

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

Sejak rilis MongoDB 2.6, Anda dapat membandingkan dengan operator $gttetapi dapat menyebabkan hasil yang tidak terduga (Anda dapat menemukan penjelasan terperinci dalam jawaban ini ):

ME.find({ pictures: { $gt: [] } })
— Chris
sumber
6
Bagi saya itu pendekatan yang benar, karena itu memastikan array ada dan tidak kosong.
— LeandroCR
Bagaimana saya bisa mencapai fungsionalitas yang sama menggunakanmongoengine
— Rohit Khatri
54
HATI-HATI, ME.find({ pictures: { $gt: [] } })BERBAHAYA, bahkan dalam versi MongoDB yang lebih baru. Jika Anda memiliki indeks pada bidang daftar Anda dan indeks itu digunakan selama permintaan, Anda akan mendapatkan hasil yang tidak terduga. Misalnya: db.doc.find({'nums': { $gt: [] }}).hint({ _id: 1 }).count()mengembalikan nomor yang benar, sementara db.doc.find({'nums': { $gt: [] }}).hint({ nums: 1 }).count()mengembalikan 0.
— wojcikstefan
1
Lihat jawaban terperinci saya di bawah ini untuk mengetahui mengapa ini mungkin tidak berhasil untuk Anda: stackoverflow.com/a/42601244/1579058
— wojcikstefan
6
Komentar @ wojcikstefan perlu ditingkatkan untuk mencegah orang menggunakan saran terakhir yang, memang, dalam keadaan tertentu tidak mengembalikan dokumen yang cocok.
— Thomas Jung
181

Setelah beberapa mencari lagi, terutama di dokumen mongodb, dan membingungkan bit, ini jawabannya:

ME.find({pictures: {$exists: true, $not: {$size: 0}}})
— skerit
sumber
27
Ini tidak berhasil. Saya tidak tahu apakah ini sebelumnya berhasil, tetapi ini juga akan mengembalikan objek yang tidak memiliki kunci 'gambar'.
— rdsoze
17
Tidak dapat dipercaya bagaimana jawaban ini memiliki 63 peningkatan, padahal sebenarnya apa yang dikatakan @rdsoze benar - kueri juga akan mengembalikan catatan yang tidak memiliki picturesbidang.
— Dan Dascalescu
5
Hati-hati, mongoDB tidak akan menggunakan indeks jika $ size melibatkan tautan . Akan lebih baik untuk memasukkan {$ ne: []} dan mungkin {$ ne: null}.
— Levente Dobson
17
@ terlalu banyak baris pertama pertanyaan menyatakan "Semua catatan saya memiliki bidang yang disebut" gambar ". Bidang ini adalah array" . Terlebih lagi, ini adalah skenario yang sangat realistis dan umum. Jawaban ini tidak salah, ia bekerja untuk pertanyaan tepat seperti yang tertulis, dan mengkritik atau merendahkannya karena fakta bahwa itu tidak menyelesaikan masalah yang berbeda adalah konyol.
— Mark Amery
1
@Cec Semua dokumentasi mengatakan bahwa jika Anda menggunakan $ size dalam kueri, itu tidak akan menggunakan indeks apa pun untuk memberi Anda hasil yang lebih cepat. Jadi jika Anda memiliki indeks pada bidang itu dan Anda ingin menggunakannya, tetap gunakan pendekatan lain seperti {$ ne: []}, jika itu berfungsi untuk Anda, itu akan menggunakan indeks Anda.
— Levente Dobson
108

Ini juga bisa bekerja untuk Anda:

ME.find({'pictures.0': {$exists: true}});
— tenbatsu
sumber
2
Bagus! Ini juga memungkinkan Anda memeriksa ukuran minimum. Apakah Anda tahu jika array selalu diindeks secara berurutan? Apakah akan pernah ada kasus di mana pictures.2ada tetapi pictures.1tidak?
— anushr
2
The $existsoperator adalah boolean, bukan offset. @tenbatsu harus menggunakan truebukan 1.
— ekillaby
2
@ anushr Would there ever be a case where pictures.2 exists but pictures.1 does not? Ya, kasus itu bisa terjadi.
— The Bndr
@TheBndr Itu hanya bisa terjadi jika picturesmerupakan sub-doc, bukan array misalnyapictures: {'2': 123}
— JohnnyHK
4
Ini bagus dan intuitif, tetapi waspadalah jika kinerjanya penting - ini akan melakukan pemindaian koleksi penuh walaupun Anda memiliki indeks pictures.
— wojcikstefan
35

Anda peduli pada dua hal saat mengajukan pertanyaan - akurasi dan kinerja. Dengan pemikiran itu, saya menguji beberapa pendekatan berbeda dalam MongoDB v3.0.14.

TL; DR db.doc.find({ nums: { $gt: -Infinity }})adalah yang tercepat dan paling dapat diandalkan (setidaknya dalam versi MongoDB yang saya uji).

EDIT: Ini tidak lagi berfungsi di MongoDB v3.6! Lihat komentar di bawah posting ini untuk solusi potensial.

Mendirikan

Saya memasukkan dokumen 1k tanpa kolom daftar, dokumen 1k dengan daftar kosong, dan 5 dokumen dengan daftar tidak kosong.

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

Saya menyadari ini bukan skala yang cukup untuk menganggap kinerja seserius saya dalam tes di bawah ini, tetapi cukup untuk menyajikan kebenaran berbagai pertanyaan dan perilaku rencana kueri yang dipilih.

Tes

db.doc.find({'nums': {'$exists': true}}) mengembalikan hasil yang salah (untuk apa yang ingin kami capai).

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

-

db.doc.find({'nums.0': {'$exists': true}})mengembalikan hasil yang benar, tetapi juga lambat menggunakan pemindaian koleksi penuh ( COLLSCANtahap pemberitahuan dalam penjelasan).

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 }}})mengembalikan hasil yang salah. Itu karena pemindaian indeks tidak valid memajukan tidak ada dokumen. Kemungkinan akan akurat tetapi lambat tanpa indeks.

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 }}})mengembalikan hasil yang benar, tetapi kinerjanya buruk. Secara teknis melakukan pemindaian indeks, tetapi kemudian masih memajukan semua dokumen dan kemudian harus menyaring melalui mereka).

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: [] }})mengembalikan hasil yang benar dan sedikit lebih cepat, tetapi kinerjanya masih tidak ideal. Ia menggunakan IXSCAN yang hanya memajukan dokumen dengan bidang daftar yang ada, tetapi kemudian harus menyaring daftar kosong satu per satu.

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: [] }})IS BERBAHAYA KARENA BERGANTUNG PADA INDEKS YANG DIGUNAKAN, MUNGKIN MEMBERIKAN HASIL YANG TIDAK DIKENALKAN. Itu karena pemindaian indeks yang tidak valid yang tidak memajukan dokumen.

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 }}) mengembalikan hasil yang benar, tetapi memiliki kinerja buruk (menggunakan pemindaian koleksi penuh).

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 }})Yang mengejutkan, ini bekerja dengan sangat baik! Ini memberikan hasil yang tepat dan cepat, memajukan 5 dokumen dari fase pemindaian indeks.

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
  }
}
— wojcikstefan
sumber
Terima kasih atas jawaban Anda yang sangat terperinci @wojcikstefan. Sayangnya, solusi yang Anda sarankan tampaknya tidak berfungsi dalam kasus saya. Saya memiliki koleksi MongoDB 3.6.4 dengan dokumen 2m, kebanyakan dari mereka memiliki seen_eventsarray String, yang juga diindeks. Mencari dengan { $gt: -Infinity }, saya langsung mendapatkan 0 dokumen. Menggunakan { $exists: true, $ne: [] }I mendapatkan dokumen 1,2m lebih mungkin, dengan banyak waktu terbuang dalam tahap FETCH: gist.github.com/N-Coder/b9e89a925e895c605d84bfeed648d82c
— NCode
Tampaknya Anda benar @Ncode - ini tidak lagi berfungsi di MongoDB v3.6 :( Saya bermain-main dengannya selama beberapa menit dan inilah yang saya temukan: 1. db.test_collection.find({"seen_events.0": {$exists: true}})buruk karena menggunakan pemindaian koleksi. 2. db.test_collection.find({seen_events: {$exists: true, $ne: []}})adalah buruk karena IXSCAN-nya cocok dengan semua dokumen dan kemudian penyaringan dilakukan dalam fase FETCH lambat 3. Sama berlaku untuk db.test_collection.find({seen_events: {$exists: true, $not: {$size: 0}}})4. Semua pertanyaan lain mengembalikan hasil yang tidak valid
— wojcikstefan
1
@NCode menemukan solusinya! Jika Anda yakin bahwa semua non-kosong seen_eventsmengandung string, Anda dapat menggunakan ini: db.test_collection.find({seen_events: {$gt: ''}}).count(). Untuk mengonfirmasi itu berfungsi dengan baik, periksa db.test_collection.find({seen_events: {$gt: ''}}).explain(true).executionStats. Anda mungkin dapat menegakkan bahwa peristiwa yang terlihat adalah string melalui validasi skema: docs.mongodb.com/manual/core/schema-validation
— wojcikstefan
Terima kasih! Semua nilai yang ada adalah string jadi saya akan mencobanya. Ada juga bug yang membahas masalah ini di bugtracker MongoDB: jira.mongodb.org/browse/SERVER-26655
— NCode
30

Dimulai dengan rilis 2.6, cara lain untuk melakukan ini adalah membandingkan bidang ke array kosong:

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

Mengujinya di shell:

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

Jadi ia dengan benar menyertakan dokumen yang picturesmemiliki setidaknya satu elemen array, dan mengecualikan dokumen yang picturesmerupakan array kosong, bukan array, atau hilang.

— JohnnyHK
sumber
7
HATI-HATI jawaban ini mungkin memberi Anda kesulitan jika Anda mencoba menggunakan indeks. Melakukan db.ME.createIndex({ pictures: 1 })dan kemudian db.ME.find({pictures: {$gt: []}})akan mengembalikan hasil nol, setidaknya di MongoDB v3.0.14
— wojcikstefan
@wojcikstefan Tangkapan yang bagus. Perlu melihat segar ini.
— JohnnyHK
5

Anda dapat menggunakan salah satu dari yang berikut untuk mencapai ini.
Keduanya juga berhati-hati agar tidak mengembalikan hasil untuk objek yang tidak memiliki kunci yang diminta di dalamnya:

db.video.find({pictures: {$exists: true, $gt: {$size: 0}}})
db.video.find({comments: {$exists: true, $not: {$size: 0}}})
— Paul Imisi
sumber
4

Ambil semua dan hanya dokumen di mana 'gambar' adalah larik dan tidak kosong

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

Jika menggunakan versi MongoDb sebelum 3.2 , gunakan $type: 4sebagai ganti $type: 'array'. Perhatikan bahwa solusi ini bahkan tidak menggunakan $ size , jadi tidak ada masalah dengan indeks ("Kueri tidak dapat menggunakan indeks untuk bagian $ size dari kueri")

Solusi lain, termasuk ini (jawaban yang diterima):

ME.find ({gambar: {$ exist: true, $ not: {$ size: 0}}}); SAYA temukan ({gambar: {$ ada: benar, $ ne: []}})

adalah salah karena mereka kembali dokumen bahkan jika, misalnya, 'gambar' adalah null, undefined, 0, dll

— SC1000
sumber
2

Gunakan $elemMatchoperator: sesuai dengan dokumentasi

Operator $ elemMatch cocok dengan dokumen yang berisi bidang array dengan setidaknya satu elemen yang cocok dengan semua kriteria permintaan yang ditentukan.

$elemMatchesmemastikan bahwa nilainya adalah array dan tidak kosong. Jadi kueri akan seperti itu

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

PS Varian dari kode ini ditemukan dalam kursus M121 Universitas MongoDB.

— Andres Moreno
sumber
0

Anda juga dapat menggunakan metode helper Ada di atas operator Mongo $ ada

ME.find()
    .exists('pictures')
    .where('pictures').ne([])
    .sort('-created')
    .limit(10)
    .exec(function(err, results){
        ...
    });
— Makanlah di Joes
sumber
0 
{ $where: "this.pictures.length > 1" }

gunakan $ mana dan lewati this.field_name.length yang mengembalikan ukuran bidang array dan memeriksanya dengan membandingkan dengan angka. jika setiap array memiliki nilai lebih dari ukuran array harus minimal 1. jadi semua field array memiliki panjang lebih dari satu, itu berarti ia memiliki beberapa data dalam array itu

— Prabhat Yadav
sumber
-8 
ME.find({pictures: {$exists: true}})

Sesederhana itu, ini berhasil untuk saya.

— Luis Fletes
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.