यह अभी भी चलाने के लिए एक अच्छी क्वेरी नहीं है, लेकिन $objectToArray के माध्यम से इसे करने का थोड़ा और आधुनिक तरीका है। और $redact
db.collection.aggregate([
{ "$redact": {
"$cond": {
"if": {
"$eq": [
{ "$size": { "$objectToArray": "$value" } },
3
]
},
"then": "$$KEEP",
"else": "$$PRUNE"
}
}}
])
जहां $objectToArray मूल रूप से ऑब्जेक्ट को एक ऐरे फॉर्म में ज़बरदस्ती करता है, बहुत कुछ Object.keys() . के संयोजन की तरह और .map() जावास्क्रिप्ट में होगा।
यह अभी भी एक शानदार विचार नहीं है क्योंकि इसके लिए पूरे संग्रह को स्कैन करने की आवश्यकता होती है, लेकिन कम से कम एकत्रीकरण ढांचे के संचालन जावास्क्रिप्ट व्याख्या के विपरीत "मूल कोड" का उपयोग करते हैं जैसा कि $where का उपयोग करने के मामले में होता है। ।
इसलिए सबसे प्रभावी क्वेरी संचालन बनाने के लिए डेटा संरचना को बदलने और प्राकृतिक सरणी के साथ-साथ संग्रहीत "आकार" गुणों का उपयोग करने की सलाह दी जाती है।
हां ऐसा करना संभव है लेकिन सबसे अच्छे तरीके से नहीं। इसका कारण यह है कि आप अनिवार्य रूप से एक $कहां
ऑपरेटर क्वेरी जो सामग्री से मेल खाने के लिए जावास्क्रिप्ट मूल्यांकन का उपयोग करती है। सबसे कुशल तरीका नहीं है क्योंकि यह कभी भी किसी अनुक्रमणिका का उपयोग नहीं कर सकता है और सभी दस्तावेज़ों का परीक्षण करने की आवश्यकता है:
db.collection.find({ "$where": "return Object.keys(this.value).length == 3" })
यह "तीन" तत्वों से मेल खाने वाली स्थिति की तलाश करता है, फिर आपके केवल दो सूचीबद्ध दस्तावेज़ वापस किए जाएंगे:
{ "_id" : "number1", "value" : { "a" : 1, "b" : 2, "f" : 5 } }
{ "_id" : "number2", "value" : { "e" : 2, "f" : 114, "h" : 12 } }
या "पांच" या अधिक फ़ील्ड के लिए आप बहुत कुछ ऐसा ही कर सकते हैं:
db.numbers.find({ "$where": "return Object.keys(this.value).length >= 5" })
तो उस ऑपरेटर के लिए तर्क प्रभावी रूप से जावास्क्रिप्ट स्टेटमेंट हैं जिनका मूल्यांकन सर्वर पर किया जाता है जहां सत्य ।
दस्तावेज़ में ही तत्वों की "गिनती" को संग्रहीत करना एक अधिक कुशल तरीका है। इस तरह आप इस क्षेत्र को "अनुक्रमित" कर सकते हैं और प्रश्न अधिक कुशल हैं क्योंकि अन्य शर्तों द्वारा चयनित संग्रह में प्रत्येक दस्तावेज़ को लंबाई निर्धारित करने के लिए स्कैन करने की आवश्यकता नहीं है:
{_id:'number1', value:{'a':1, 'b':2, 'f':5} count: 3},
{_id:'number2', value:{'e':2, 'f':114, 'h':12}, count: 3},
{_id:'number3', value:{'i':2, 'j':22, 'z':12, 'za':111, 'zb':114}, count: 5}
फिर "पांच" तत्वों वाले दस्तावेज़ प्राप्त करने के लिए आपको केवल साधारण क्वेरी की आवश्यकता है:
db.collection.find({ "count": 5 })
यह आम तौर पर सबसे इष्टतम रूप है। लेकिन एक और बिंदु यह है कि सामान्य "ऑब्जेक्ट" संरचना जिसे आप सामान्य अभ्यास से खुश कर सकते हैं वह ऐसा कुछ नहीं है जो मोंगोडीबी सामान्य रूप से "अच्छा खेलता है"। समस्या वस्तु में तत्वों का "ट्रैवर्सल" है, और इस तरह जब आप "सरणी" का उपयोग करते हैं तो मोंगोडीबी बहुत खुश होता है। और इस रूप में भी:
{
'_id': 'number1',
'values':[
{ 'key': 'a', 'value': 1 },
{ 'key': 'b', 'value': 2 },
{ 'key': 'f', 'value': 5 }
],
},
{
'_id': 'number2',
'values':[
{ 'key': 'e', 'value': 2 },
{ 'key': 'f', 'value': 114 },
{ 'key': 'h', 'value': 12 }
],
},
{
'_id':'number3',
'values': [
{ 'key': 'i', 'values': 2 },
{ 'key': 'j', 'values': 22 },
{ 'key': 'z'' 'values': :12 },
{ 'key': 'za', 'values': 111 },
{ 'key': 'zb', 'values': 114 }
]
}
इसलिए यदि आप वास्तव में उस तरह के "सरणी" प्रारूप में स्विच करते हैं तो आप एक सटीक . कर सकते हैं $ के एक संस्करण के साथ एक सरणी की लंबाई आकार
ऑपरेटर:
db.collection.find({ "values": { "$size": 5 } })
वह ऑपरेटर सटीक . के लिए काम कर सकता है एक सरणी लंबाई के लिए मान क्योंकि यह इस ऑपरेटर के साथ क्या किया जा सकता है इसका एक मूल प्रावधान है। आप क्या नहीं कर सकते जैसा कि "इन-इक्वेलिटी" मैच में प्रलेखित है। उसके लिए आपको MongoDB के लिए "एग्रीगेशन फ्रेमवर्क" की आवश्यकता है, जो कि JavaScript और mapReduce ऑपरेशंस के लिए एक बेहतर विकल्प है:
db.collection.aggregate([
// Project a size of the array
{ "$project": {
"values": 1,
"size": { "$size": "$values" }
}},
// Match on that size
{ "$match": { "size": { "$gte": 5 } } },
// Project just the same fields
{{ "$project": {
"values": 1
}}
])
तो वे पर्यायवाची हैं। एकत्रीकरण और एक सरणी प्रकार के लिए एक "मूल" विधि उपलब्ध है। लेकिन यह काफी तर्कपूर्ण है कि जावास्क्रिप्ट मूल्यांकन भी MongoDB के लिए "मूल" है, इसलिए इसे मूल कोड में लागू नहीं किया गया है।
