Permintaan dokumen dengan ukuran array lebih besar dari 1

Saya memiliki koleksi MongoDB dengan dokumen dalam format berikut:

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

Saat ini saya bisa mendapatkan dokumen yang cocok dengan ukuran array tertentu:

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

Ini dengan benar mengembalikan dokumen dengan 2 elemen dalam namearray. Namun, saya tidak bisa melakukan $gtperintah untuk mengembalikan semua dokumen yang namebidangnya memiliki ukuran array lebih dari 2:

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

Bagaimana saya bisa memilih semua dokumen dengan namearray ukuran lebih besar dari satu (lebih disukai tanpa harus mengubah struktur data saat ini)?

Memperbarui:

Untuk mongodb versi 2.2 + cara yang lebih efisien untuk melakukan hal ini dijelaskan oleh @JohnnyHK di lain jawabannya .

1.Menggunakan $ di mana

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

Tapi...

Javascript dijalankan lebih lambat dari operator asli yang tercantum di halaman ini, tetapi sangat fleksibel. Lihat halaman pemrosesan sisi server untuk informasi lebih lanjut.

2.Buat bidang tambahanNamesArrayLength , perbarui dengan panjang array nama dan kemudian gunakan dalam permintaan:

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

Ini akan menjadi solusi yang lebih baik, dan akan bekerja lebih cepat (Anda dapat membuat indeks di atasnya).

Ada cara yang lebih efisien untuk melakukan ini di MongoDB 2.2+ sekarang Anda dapat menggunakan indeks array numerik dalam kunci objek kueri.

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

Anda dapat mendukung permintaan ini dengan indeks yang menggunakan ekspresi filter parsial (membutuhkan 3,2+):

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

Saya percaya ini adalah permintaan tercepat yang menjawab pertanyaan Anda, karena itu tidak menggunakan $whereklausa yang ditafsirkan :

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

Ini berarti "semua dokumen kecuali yang tanpa nama (baik array yang tidak ada atau kosong) atau hanya dengan satu nama."

Uji:

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

Anda juga dapat menggunakan agregat:

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

// Anda menambahkan "size_of_name" ke transit dokumen dan menggunakannya untuk menyaring ukuran nama

Coba lakukan sesuatu seperti ini:

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

1 adalah angka, jika Anda ingin mengambil catatan yang lebih besar dari 50 maka lakukan ArrayName.50 Terima kasih.

Tak satu pun dari yang di atas bekerja untuk saya. Yang ini jadi saya bagikan:

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

Anda dapat menggunakan $ expr (operator versi 3,6 mongo) untuk menggunakan fungsi agregasi dalam kueri reguler.

Bandingkan query operatorsvs aggregation comparison operators.

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

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

MongoDB 3.6 termasuk $ expr https://docs.mongodb.com/manual/reference/operator/query/expr/

Anda dapat menggunakan $ expr untuk mengevaluasi ekspresi di dalam $ match, atau menemukan.

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

atau temukan

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

Saya menemukan solusi ini, untuk menemukan item dengan bidang array yang lebih besar dari panjang tertentu

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

Agregat $ pertandingan pertama menggunakan argumen yang benar untuk semua dokumen. Jika kosong, saya akan mendapatkannya

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

Saya tahu pertanyaan lamanya, tetapi saya mencoba ini dengan $ gte dan $ size. Saya pikir untuk menemukan () lebih cepat.

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

Meskipun jawaban di atas semuanya berfungsi, Apa yang awalnya Anda coba lakukan adalah cara yang benar, namun Anda hanya memiliki sintaks mundur (beralih "$ size" dan "$ gt") ..

Benar:

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

Salah:

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