Dizi alanının boş olmadığı MongoDB kayıtlarını bulma

502

Tüm kayıtlarımın "resim" adlı bir alanı var. Bu alan bir dize dizisidir.

Şimdi bu dizi boş DEĞİL en yeni 10 kayıtları istiyorum.

Etrafta dolaştım, ama garip bir şekilde bu konuda fazla bir şey bulamadım. $ Nerede seçeneğini okudum, ama yerel işlevler için ne kadar yavaş olduğunu ve daha iyi bir çözüm olup olmadığını merak ediyordum.

Ve o zaman bile, bu işe yaramaz:

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

Hiçbir şey döndürmez. this.picturesUzunluk biti olmadan ayrılmak işe yarar, ama sonra elbette boş kayıtları da döndürür.

mongodb  mongoose 
— skerit
kaynak

Yanıtlar:

827

Anahtarı olmayan belgeleriniz de varsa, şunları kullanabilirsiniz:

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

MongoDB, $ size dahilse dizin kullanmaz, işte daha iyi bir çözüm:

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

MongoDB 2.6 sürümünden bu yana, operatörle karşılaştırabilirsiniz, $gtancak beklenmedik sonuçlara yol açabilir ( bu cevapta ayrıntılı bir açıklama bulabilirsiniz ):

ME.find({ pictures: { $gt: [] } })
— Chris'
kaynak
6
Benim için doğru yaklaşım bu, çünkü dizinin var olduğundan ve boş olmadığından emin oluyor.
— LeandroCR
Aynı işlevselliği kullanarak nasıl elde edebilirimmongoengine
— Rohit Khatri
54
DİKKATLİ, ME.find({ pictures: { $gt: [] } })daha yeni MongoDB versiyonlarında bile TEHLİKELİDİR. Liste alanınızda bir dizin varsa ve bu dizin sorgu sırasında kullanılırsa, beklenmedik sonuçlar alırsınız. Örneğin: db.doc.find({'nums': { $gt: [] }}).hint({ _id: 1 }).count()doğru sayıyı db.doc.find({'nums': { $gt: [] }}).hint({ nums: 1 }).count()döndürürken döner 0.
— wojcikstefan
1
Bunun sizin için neden işe yaramayabileceğini öğrenmek için aşağıdaki ayrıntılı cevabımı görün: stackoverflow.com/a/42601244/1579058
— wojcikstefan
6
@ wojcikstefan'ın yorumunun, insanların belirli koşullar altında eşleşen belgeleri döndürmeyen son öneriyi kullanmasını önlemek için kaldırılması gerekir.
— Thomas Jung
181

Biraz daha baktıktan sonra, özellikle mongodb belgelerinde ve kafa karıştırıcı bitlerle birlikte, cevap buydu:

ME.find({pictures: {$exists: true, $not: {$size: 0}}})
— skerit
kaynak
27
Bu işe yaramıyor. Bunun daha önce çalışıp çalışmadığını bilmiyorum, ama bu aynı zamanda 'resim' tuşu olmayan nesneleri de döndürecek.
— rdsoze
17
Bu cevabın 63 yukarı oyu var, aslında @rdsoze'nin söyledikleri doğru olduğunda - sorgu da alana sahip olmayan kayıtları döndürecektir pictures.
— Dan Dascalescu
5
Dikkatli olun, $ size dahil bağlantı varsa mongoDB dizin kullanmaz . {$ Ne: []} ve muhtemelen {$ ne: null} içermesi daha iyi olur.
— Levente Dobson
17
@rdsoze ilk satırı soru durumlarının resimleri "bir saha çağrıda benim kayıtların All ''. Bu alan bir dizidir" . Dahası, bu oldukça gerçekçi ve yaygın bir senaryodur. Bu cevap yanlış değil, soru için tam olarak yazıldığı gibi çalışıyor ve farklı bir sorunu çözmediği için eleştirmek veya küçümsemek aptalca.
— Mark Amery
1
@Cec Tüm belgelerde, sorguda $ size kullanırsanız, size daha hızlı sonuç vermek için herhangi bir dizin kullanılmayacağı söylenir. Bu alanda bir dizininiz varsa ve onu kullanmak istiyorsanız, {$ ne: []} gibi diğer yaklaşımlara sadık kalın, bu sizin için işe yararsa, dizininizi kullanır.
— Levente Dobson
108

Bu sizin için de işe yarayabilir:

ME.find({'pictures.0': {$exists: true}});
— tenbatsu
kaynak
2
Güzel! Bu ayrıca minimum boyutu kontrol etmenizi sağlar. Dizilerin her zaman ardışık olarak dizine eklenip eklenmediğini biliyor musunuz? Var olan pictures.2ama pictures.1olmayan bir durum olur mu?
— anushr
2
$existsOperatör bir ofset bir boolean değil. trueyerine @tenbatsu kullanılmalıdır 1.
— ekillaby
2
@anushr Would there ever be a case where pictures.2 exists but pictures.1 does not? Evet, bu durum olabilir.
— The Bndr
@TheBndr Bu yalnızca picturesbir dizi değil, bir alt belge olduğunda gerçekleşebilir . ör.pictures: {'2': 123}
— JohnnyHK
4
Bu güzel ve sezgisel, ancak performansın önemli olup olmadığına dikkat edin - üzerinde bir endeksiniz olsa bile tam bir koleksiyon taraması yapar pictures.
— wojcikstefan
35

Sorgularken iki şeye önem veriyorsunuz - doğruluk ve performans. Bunu göz önünde bulundurarak, MongoDB v3.0.14'te birkaç farklı yaklaşımı test ettim.

TL; DR db.doc.find({ nums: { $gt: -Infinity }})en hızlı ve en güvenilir olanıdır (en azından test ettiğim MongoDB versiyonunda).

EDIT: Bu artık MongoDB v3.6 çalışmıyor! Olası bir çözüm için bu yazının altındaki yorumlara bakın.

Kurmak

Liste alanına 1k dokümanlar, boş listeye sahip 1k dokümanlar ve boş olmayan listeye sahip 5k dokümanlar ekledim.

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

Bunun, aşağıdaki testlerde olduğu gibi performansı ciddiye almak için yeterli bir ölçek olmadığının farkındayım, ancak seçilen sorgu planlarının çeşitli sorgularının ve davranışlarının doğruluğunu sunmak yeterli.

Testler

db.doc.find({'nums': {'$exists': true}}) yanlış sonuçlar döndürür (gerçekleştirmeye çalıştığımız şey için).

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

-

db.doc.find({'nums.0': {'$exists': true}})doğru sonuçları döndürür, ancak tam toplama taraması ( COLLSCANaçıklamadaki uyarı aşaması) da yavaştır .

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 }}})yanlış sonuçlar döndürür. Bunun nedeni, hiçbir belgeyi ilerletmeyen geçersiz bir dizin taramasıdır. Dizin olmadan muhtemelen doğru ama yavaş olacaktır.

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 }}})doğru sonuçları döndürür, ancak performans kötüdür. Teknik olarak bir dizin taraması yapar, ancak yine de tüm dokümanları ilerletir ve ardından filtrelemek zorundadır).

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: [] }})doğru sonuçları döndürür ve biraz daha hızlıdır, ancak performans yine de ideal değildir. Yalnızca varolan bir liste alanına sahip belgeleri ilerleten IXSCAN kullanır, ancak daha sonra boş listeleri tek tek filtrelemek zorundadır.

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: [] }})KULLANILAN İNDEKSE BAĞLI TEHLİKELİ OLMAK ÜZERE BEKLENMEYEN SONUÇLAR OLABİLİR. Bunun nedeni, hiçbir belgeyi ilerletmeyen geçersiz bir dizin taramasıdır.

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 }}) doğru sonuçları döndürür, ancak performansı kötüdür (tam toplama taraması kullanır).

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 }})şaşırtıcı bir şekilde, bu çok iyi çalışıyor! Doğru sonuçları verir ve hızlıdır, indeks tarama aşamasından 5 doküman ilerletir.

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
kaynak
Çok ayrıntılı cevabınız için teşekkürler @wojcikstefan. Ne yazık ki, önerdiğiniz çözüm benim durumumda çalışmıyor gibi görünüyor. Çoğu seen_eventsda dizine alınmış bir String dizisi olan 2m belgeleri ile bir MongoDB 3.6.4 koleksiyonu var . İle { $gt: -Infinity }aradığımda hemen 0 belge alıyorum. Kullanımı { $exists: true, $ne: [] }çok zaman içinde harcanarak, ben daha olası 1,2m docs olsun sahne FETCH: gist.github.com/N-Coder/b9e89a925e895c605d84bfeed648d82c
— nCode
Size şeyiz sağ @Ncode görünüyor - MongoDB v3.6 bu artık eser :( Birkaç dakika oynadı kendisiyle ve burada ne buldum: 1. db.test_collection.find({"seen_events.0": {$exists: true}})Bir toplama tarama kullanması nedeniyle kötü 2.. db.test_collection.find({seen_events: {$exists: true, $ne: []}})Olduğunu . kötü onun IXSCAN tüm belgeleri ile eşleşen ve daha sonra filtreleme yavaş FETCH aşamasında gerçekleştirilir çünkü aynı 3. için de geçerli db.test_collection.find({seen_events: {$exists: true, $not: {$size: 0}}})4. diğer tüm sorgular geçersiz sonuçları döndürür..
— wojcikstefan
1
@NCode bir çözüm buldu! Tüm boş olmayan eminseniz seen_eventsdizeleri içeren bu kullanabilirsiniz: db.test_collection.find({seen_events: {$gt: ''}}).count(). İyi çalıştığını doğrulamak için kontrol edin db.test_collection.find({seen_events: {$gt: ''}}).explain(true).executionStats. Muhtemelen görülen olayların şema doğrulamasıyla dizeler olduğunu zorunlu kılabilirsiniz : docs.mongodb.com/manual/core/schema-validation
— wojcikstefan
Teşekkürler! Mevcut tüm değerler dizelerdir, bu yüzden bunu deneyeceğim. MongoDB hata takipçisinde bu sorunu tartışan bir hata var: jira.mongodb.org/browse/SERVER-26655
— NCode
30

2.6 sürümünden başlayarak, bunu yapmanın başka bir yolu da alanı boş bir diziyle karşılaştırmaktır:

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

Kabukta test etme:

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

Bu nedenle pictures, en az bir dizi öğesinin bulunduğu dokümanları düzgün bir şekilde içerir ve bir dizi picturesdeğil, boş bir dizi veya eksik olan dokümanları hariç tutar .

— JohnnyHK
kaynak
7
DİKKAT bu cevap dizinleri kullanmaya çalışırsanız size sorun verebilir. Bunu yapmak db.ME.createIndex({ pictures: 1 })ve daha sonra db.ME.find({pictures: {$gt: []}})sıfır sonuç döndürür, en azından MongoDB v3.0.14
— wojcikstefan
@wojcikstefan İyi yakaladım. Buna yeni bir göz atmanız gerekiyor.
— JohnnyHK
5

Bunu başarmak için aşağıdakilerden herhangi birini kullanabilirsiniz.
Her ikisi de, içinde istenen anahtar bulunmayan nesneler için bir sonuç döndürmemeye dikkat eder:

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

'Resimlerin' bir dizi olduğu ve boş olmadığı tüm belgeleri alın

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

Bir mongodb sürümünü öncesinde kullanılıyorsa 3.2 , kullanmak $type: 4yerine $type: 'array'. Bu çözümün $ size bile kullanmadığına dikkat edin, bu nedenle dizinlerle ilgili bir sorun yoktur ("Sorgular, sorgunun $ size bölümü için dizin kullanamaz")

Bunlar dahil diğer çözümler (kabul edilen cevap):

ME.find ({pictures: {$ mevcut: true, $ not: {$ size: 0}}}); ME.find ({resimler: {$ mevcut: doğru, $ ne: []}})

Hangi yanlış bunlar örneğin, belgeler bile dönmek çünkü, 'resimler' olduğu null, undefined0, vb

— SC1000
kaynak
2

$elemMatchOperatörü kullanın : belgelere göre

$ ElemMatch operatörü, bir dizi alanı içeren belgeleri, belirtilen tüm sorgu ölçütleriyle eşleşen en az bir öğeyle eşleştirir.

$elemMatchesdeğerin bir dizi olduğundan ve boş olmadığından emin olur. Yani sorgu,

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

PS Bu kodun bir çeşidi MongoDB Üniversitesi M121 kursunda bulunur.

— Andres Moreno
kaynak
0

Ayrıca, yardımcı bir yöntem kullanabilirsiniz Var Mongo operatör $ var üzerinde

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

$ where komutunu kullanın ve dizi alanının boyutunu döndüren this.field_name.length dosyasını iletin ve sayı ile karşılaştırarak kontrol edin. herhangi bir dizinin dizi boyutundan başka bir değeri varsa en az 1 olması gerekir, bu nedenle tüm dizi alanının uzunluğu birden fazla olduğunda, bu dizide bazı veriler olduğu anlamına gelir

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

Bu kadar basit, bu benim için çalıştı.

— Luis Fletes
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.