ค้นหาระเบียน MongoDB โดยที่ฟิลด์อาร์เรย์ไม่ว่างเปล่า

บันทึกทั้งหมดของฉันมีเขตข้อมูลที่เรียกว่า "รูปภาพ" ฟิลด์นี้เป็นอาร์เรย์ของสตริง

ตอนนี้ฉันต้องการ 10 ระเบียนใหม่ล่าสุดที่อาร์เรย์นี้ไม่ว่างเปล่า

ฉันไปเที่ยวไปรอบ ๆ แต่ก็แปลกพอที่ฉันไม่ได้เจออะไรมากมาย ฉันได้อ่านตัวเลือก $ where แล้ว แต่ฉันสงสัยว่ามันช้าแค่ไหนสำหรับฟังก์ชั่นพื้นฐานและถ้ามีทางออกที่ดีกว่า

และถึงอย่างนั้นก็ไม่ได้ผล:

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

ไม่ส่งคืนอะไรเลย การออกไปthis.picturesโดยไม่ใช้บิตความยาวนั้นสามารถใช้งานได้

หากคุณมีเอกสารที่ไม่มีกุญแจคุณสามารถใช้:

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

MongoDB ไม่ใช้ดรรชนีถ้าเกี่ยวข้องกับขนาด $ ดังนั้นนี่เป็นทางออกที่ดีกว่า:

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

เนื่องจาก MongoDB 2.6 รีลีสคุณสามารถเปรียบเทียบกับโอเปอเรเตอร์$gtแต่อาจนำไปสู่ผลลัพธ์ที่ไม่คาดคิด (คุณสามารถหาคำอธิบายที่ไม่ได้รับคำอธิบายในคำตอบนี้ ):

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

หลังจากดูเพิ่มเติมโดยเฉพาะในเอกสาร mongodb และ puzzling บิตด้วยกันนี่คือคำตอบ:

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

สิ่งนี้อาจใช้ได้กับคุณ:

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

คุณใส่ใจสองสิ่งในการสอบถาม - ความแม่นยำและประสิทธิภาพ โดยที่ในใจฉันทดสอบวิธีต่าง ๆ ใน MongoDB v3.0.14

TL; DR db.doc.find({ nums: { $gt: -Infinity }})เป็นวิธีที่เร็วและเชื่อถือได้มากที่สุด (อย่างน้อยใน MongoDB ที่ฉันทดสอบ)

แก้ไข: สิ่งนี้ไม่ทำงานใน MongoDB v3.6 อีกต่อไป! ดูความคิดเห็นภายใต้โพสต์นี้เพื่อหาแนวทางแก้ไข

ติดตั้ง

ฉันได้แทรกฟิลด์รายการเอกสาร 1k w / oa เอกสาร 1k ที่มีรายการว่างเปล่าและเอกสาร 5 รายการด้วยรายการที่ไม่ว่างเปล่า

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

ฉันรู้ว่านี่ไม่เพียงพอที่จะแสดงประสิทธิภาพอย่างจริงจังเหมือนที่ฉันทำในการทดสอบด้านล่าง แต่ก็เพียงพอที่จะนำเสนอความถูกต้องของข้อความค้นหาและพฤติกรรมของแผนการสืบค้นที่เลือกไว้

การทดสอบ

db.doc.find({'nums': {'$exists': true}}) ส่งคืนผลลัพธ์ที่ไม่ถูกต้อง (สำหรับสิ่งที่เราพยายามทำให้สำเร็จ)

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

-

db.doc.find({'nums.0': {'$exists': true}})ผลตอบแทนที่ได้แก้ไขผล แต่ก็ยังช้าโดยใช้คอลเลกชันเต็มสแกน (แจ้งให้ทราบCOLLSCANขั้นตอนในคำอธิบาย)

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 }}})ส่งคืนผลลัพธ์ที่ผิด นั่นเป็นเพราะการสแกนดัชนีที่ไม่ถูกต้องไม่มีเอกสารใด ๆ เลย มันอาจจะถูกต้อง แต่ช้าโดยไม่มีดัชนี

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 }}})ส่งคืนผลลัพธ์ที่ถูกต้อง แต่ประสิทธิภาพไม่ดี ในทางเทคนิคจะทำการสแกนดัชนี แต่ก็ยังก้าวหน้าเอกสารทั้งหมดแล้วต้องกรองผ่านพวกเขา)

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: [] }})ส่งคืนผลลัพธ์ที่ถูกต้องและเร็วขึ้นเล็กน้อย แต่ประสิทธิภาพยังไม่เหมาะ มันใช้ IXSCAN ซึ่งทำเอกสารล่วงหน้าด้วยฟิลด์รายการที่มีอยู่เท่านั้น แต่ต้องกรองรายการว่างทีละรายการ

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: [] }})เป็นอันตรายเนื่องจากขึ้นอยู่กับดัชนีที่ใช้อาจทำให้ได้ผลลัพธ์ที่ไม่คาดคิด นั่นเป็นเพราะการสแกนดัชนีที่ไม่ถูกต้องซึ่งไม่มีเอกสารล่วงหน้า

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 }}) ส่งคืนผลลัพธ์ที่ถูกต้อง แต่มีประสิทธิภาพไม่ดี (ใช้การสแกนแบบเต็มชุด)

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 }})น่าประหลาดใจที่ใช้งานได้ดีมาก! มันให้ผลลัพธ์ที่ถูกต้องและรวดเร็ว 5 เอกสารจากการสแกนดัชนีขั้นสูง

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

เริ่มต้นด้วยการเปิดตัว 2.6 วิธีอื่นในการทำเช่นนี้คือการเปรียบเทียบฟิลด์กับอาร์เรย์ว่าง:

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

ทดสอบในเปลือก:

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

ดังนั้นจึงมีเอกสารอย่างถูกต้องที่picturesมีองค์ประกอบอาเรย์อย่างน้อยหนึ่งรายการและแยกเอกสารที่picturesเป็นอาเรย์ที่ว่างเปล่าไม่ใช่อาเรย์หรือขาดหายไป

คุณสามารถใช้ข้อใดข้อหนึ่งต่อไปนี้เพื่อบรรลุเป้าหมาย
ทั้งคู่ยังดูแลไม่ส่งคืนผลลัพธ์สำหรับวัตถุที่ไม่มีรหัสที่ร้องขอในพวกเขา:

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

รับเอกสารทั้งหมดที่ 'รูปภาพ' เป็นอาร์เรย์และไม่ว่างเปล่า

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

ถ้าใช้รุ่น MongoDB ก่อน3.2ใช้แทน$type: 4 $type: 'array'โปรดสังเกตว่าโซลูชันนี้ไม่ได้ใช้ขนาด $ดังนั้นจึงไม่มีปัญหากับดัชนี ("แบบสอบถามไม่สามารถใช้ดัชนีสำหรับส่วนขนาด $ ของแบบสอบถาม")

โซลูชันอื่น ๆ รวมถึงเหล่านี้ (คำตอบที่ยอมรับ):

ME.find ({รูปภาพ: {$ มีอยู่: จริง, ไม่ใช่ $: {$ ขนาด: 0}}}); ME.find ({รูปภาพ: {$ มีอยู่: จริง, $ ne: []}})

มีความผิดเพราะพวกเขาส่งเอกสารแม้ว่าตัวอย่างเช่น 'ภาพ' เป็นnull, undefined, 0, ฯลฯ

ใช้$elemMatchโอเปอเรเตอร์: ตามเอกสารประกอบ

ตัวดำเนินการ $ elemMatch จับคู่เอกสารที่มีเขตข้อมูลอาร์เรย์ที่มีองค์ประกอบอย่างน้อยหนึ่งรายการที่ตรงกับเกณฑ์แบบสอบถามที่ระบุทั้งหมด

$elemMatchesทำให้แน่ใจว่าค่านั้นเป็นอาร์เรย์และไม่ว่างเปล่า ดังนั้นแบบสอบถามจะเป็นสิ่งที่ต้องการ

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

ป.ล. พบรหัสของตัวแปรนี้ในหลักสูตร M121 ของมหาวิทยาลัย MongoDB

นอกจากนี้คุณยังสามารถใช้วิธีผู้ช่วยที่มีอยู่มากกว่าตัวดำเนินการ Mongo ที่มีอยู่

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

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

ใช้ $ where และส่ง this.field_name.length ซึ่งส่งคืนขนาดของฟิลด์ array และตรวจสอบโดยเปรียบเทียบกับตัวเลข ถ้าอาเรย์ใด ๆ มีค่าใด ๆ เกินขนาดอาเรย์จะต้องมีอย่างน้อย 1 ดังนั้นฟิลด์อาเรย์ทั้งหมดจะมีความยาวมากกว่าหนึ่งมันหมายความว่ามันมีข้อมูลบางอย่างในอาเรย์นั้น

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

ง่ายเหมือนที่มันทำงานให้ฉัน