MongoDB में, $max
एग्रीगेशन पाइपलाइन ऑपरेटर एक एक्सप्रेशन से अधिकतम मान लौटाता है।
सिंटैक्स
$max
ऑपरेटर दो सिंटैक्स का समर्थन करता है।
सिंटैक्स 1:
{ $max: <expression> }
सिंटैक्स 2:
{ $max: [ <expression1>, <expression2> ... ] }
पहला सिंटैक्स एक तर्क को स्वीकार करता है और दूसरा सिंटैक्स कई तर्कों को स्वीकार करता है।
जब $group
. में उपयोग किया जाता है चरण, आप केवल पहले सिंटैक्स का उपयोग कर सकते हैं। इस मामले में, $max
कुंजी द्वारा समान समूह को साझा करने वाले दस्तावेज़ों के समूह में प्रत्येक दस्तावेज़ में व्यंजक लागू करने के परिणामस्वरूप प्राप्त होने वाला अधिकतम मान लौटाता है।
सिंटैक्स 1 के उदाहरण (एकल तर्क)
यहां कुछ उदाहरण दिए गए हैं जो एकल तर्क सिंटैक्स का उपयोग करते हैं।
समूहीकृत दस्तावेज़
यह उदाहरण $max
. का उपयोग करता है $group
. के संयोजन के साथ कुंजी द्वारा समूहीकृत दस्तावेज़ों के समूह से अधिकतम मान वापस करने के लिए।
मान लीजिए हमारे पास pets
. नामक संग्रह है निम्नलिखित दस्तावेजों के साथ:
{ "_id" : 1, "name" : "Wag", "type" : "Dog", "weight" : 20 } { "_id" : 2, "name" : "Bark", "type" : "Dog", "weight" : 10 } { "_id" : 3, "name" : "Meow", "type" : "Cat", "weight" : 7 } { "_id" : 4, "name" : "Scratch", "type" : "Cat", "weight" : 8 } { "_id" : 5, "name" : "Bruce", "type" : "Kangaroo", "weight" : 100 } { "_id" : 6, "name" : "Hop", "type" : "Kangaroo", "weight" : 130 } { "_id" : 7, "name" : "Punch", "type" : "Kangaroo", "weight" : 200 } { "_id" : 8, "name" : "Snap", "type" : "Cat", "weight" : 12 } { "_id" : 9, "name" : "Ruff", "type" : "Dog", "weight" : 30 }
हम इन दस्तावेज़ों को उनके type
. के आधार पर समूहित कर सकते हैं फ़ील्ड, और फिर $max
. का उपयोग करें weight
. का अधिकतम मान लौटाने के लिए प्रत्येक समूह के लिए फ़ील्ड:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
max: { $max: "$weight" }
}
}
]
)
परिणाम:
{ "_id" : "Kangaroo", "max" : 200 } { "_id" : "Cat", "max" : 12 } { "_id" : "Dog", "max" : 30 }
सरणी
यह उदाहरण $max
. पर लागू होता है एक एकल दस्तावेज़ के लिए जिसमें मानों की एक सरणी वाला फ़ील्ड होता है।
यह विकल्प केवल एकल तर्क सिंटैक्स का उपयोग करते समय उपलब्ध होता है। बहु-तर्क सिंटैक्स का उपयोग करते समय सरणियों को अनदेखा कर दिया जाता है (इस पर और अधिक नीचे)।
मान लीजिए हमारे पास players
. नामक संग्रह है निम्नलिखित दस्तावेजों के साथ:
{ "_id" : 1, "player" : "Homer", "scores" : [ 1, 7, 2, 3, 8, 7, 1 ] } { "_id" : 2, "player" : "Marge", "scores" : [ 0, 1, 8, 17, 18, 8 ] } { "_id" : 3, "player" : "Bart", "scores" : [ 15, 11, 8, 0, 1, 3 ] } { "_id" : 4, "player" : "Brian", "scores" : [ 7 ] } { "_id" : 5, "player" : "Farnsworth", "scores" : [ ] } { "_id" : 6, "player" : "Meg", "scores" : null } { "_id" : 7, "player" : "Ron" }
हम $max
. लागू कर सकते हैं scores
. तक प्रत्येक दस्तावेज़ में फ़ील्ड:
db.players.aggregate(
[
{
$project:
{
player: 1,
max: { $max: "$scores" }
}
}
]
)
परिणाम:
{ "_id" : 1, "player" : "Homer", "max" : 8 } { "_id" : 2, "player" : "Marge", "max" : 18 } { "_id" : 3, "player" : "Bart", "max" : 15 } { "_id" : 4, "player" : "Brian", "max" : 7 } { "_id" : 5, "player" : "Farnsworth", "max" : null } { "_id" : 6, "player" : "Meg", "max" : null } { "_id" : 7, "player" : "Ron", "max" : null }
इस मामले में, पहले चार दस्तावेज़ों ने उनके संबंधित सरणियों में मौजूद विभिन्न संख्याओं से अधिकतम मान लौटाया।
दस्तावेज़ 4 के मामले में, यह संख्या के समान ही था, क्योंकि सरणी में केवल एक ही संख्या थी।
दस्तावेज़ 5 लौटा null
क्योंकि हमने एक खाली सरणी प्रदान की है।
दस्तावेज़ 6 लौटा null
क्योंकि हमने null
प्रदान किया है तर्क के रूप में।
दस्तावेज़ 7 लौटा null
क्योंकि फ़ील्ड मौजूद ही नहीं था।
सिंटैक्स 2 का उदाहरण (एकाधिक तर्क)
दूसरे सिंटैक्स में $max
. प्रदान करना शामिल है एक से अधिक तर्क के साथ। $max
फिर सभी दिए गए तर्कों से अधिकतम मान लौटाता है।
मान लीजिए हमारे पास data
. नामक संग्रह है निम्नलिखित दस्तावेज़ के साथ:
{ "_id" : 1, "a" : 10, "b" : 500, "c" : -900, "d" : 4 }
हम $max
. का उपयोग कर सकते हैं a
. से अधिकतम मान वापस करने के लिए , b
, c
, और d
फ़ील्ड:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
max: { $max: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)
परिणाम:
{ "_id" : 1, "max" : 500 }
इस मामले में, 500
अधिकतम मूल्य था।
अनुपलब्ध फ़ील्ड
बहु-तर्क सिंटैक्स का उपयोग करते समय, $max
किसी भी लापता फ़ील्ड को अनदेखा करता है। यही है, यदि आप किसी ऐसे क्षेत्र की आपूर्ति करते हैं जो मौजूद नहीं है, तो वह इसे अनदेखा कर देता है। यदि कोई भी फ़ील्ड मौजूद नहीं है, तो यह null
लौटाता है ।
उदाहरण:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
max: { $max: [ "$a", "$b", "$c", "$d", "$e" ] }
}
}
]
)
परिणाम:
{ "_id" : 1, "max" : 500 }
इस मामले में मैंने एक अतिरिक्त क्षेत्र प्रदान किया ($e
) जो दस्तावेज़ में मौजूद नहीं है। $max
शेष फ़ील्ड के आधार पर अधिकतम मान की गणना की जो करते हैं मौजूद है।
हालांकि, यहां क्या होता है जब कोई नहीं फ़ील्ड मौजूद हैं:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 1 ] } } },
{
$project:
{
result: { $max: [ "$x", "$y", "$z" ] }
}
}
]
)
परिणाम:
{ "_id" : 1, "result" : null }
परिणाम null
है .
जैसा कि हमने पहले देखा, एकल-तर्क सिंटैक्स का उपयोग करते समय, एक अनुपलब्ध फ़ील्ड का परिणाम null
होता है ।
उदाहरण:
db.pets.aggregate(
[
{
$group:
{
_id: "$type",
max: { $max: "$oops!" }
}
}
]
)
परिणाम:
{ "_id" : "Dog", "max" : null } { "_id" : "Kangaroo", "max" : null } { "_id" : "Cat", "max" : null }
विभिन्न प्रकारों की तुलना करना
$max
ऑपरेटर मूल्य और प्रकार दोनों की तुलना करता है। जब मान अलग-अलग प्रकार के हों, $max
बीएसओएन तुलना क्रम के आधार पर अधिकतम मूल्य की गणना करता है।
मान लीजिए हमारे संग्रह में निम्नलिखित दस्तावेज हैं:
{ "_id" : 2, "a" : 1, "b" : 2, "c" : 3, "d" : [ 1 ] } { "_id" : 3, "a" : 1, "b" : 2, "c" : 3, "d" : "1" } { "_id" : 4, "a" : "One", "b" : "Two", "c" : "Three", "d" : "Four" } { "_id" : 5, "a" : ISODate("1999-01-03T23:30:15.100Z"), "b" : ISODate("2000-01-03T23:30:15.100Z") } { "_id" : 6, "a" : ISODate("1999-01-03T23:30:15.100Z"), "b" : "2000-01-03T23:30:15.100Z" }
दस्तावेज़ 4 के अपवाद के साथ, उनमें से प्रत्येक दस्तावेज़ मिश्रित प्रकार का उपयोग करता है (डेटा फ़ील्ड में कम से कम एक प्रकार अन्य से भिन्न होता है)। दस्तावेज़ 4 चारों क्षेत्रों में स्ट्रिंग्स का उपयोग करता है।
यहां बताया गया है कि जब हम $max
लागू करते हैं तो क्या होता है उन दस्तावेज़ों के लिए:
db.data.aggregate(
[
{ $match: { _id: { $in: [ 2, 3, 4, 5, 6 ] } } },
{
$project:
{
max: { $max: [ "$a", "$b", "$c", "$d" ] }
}
}
]
)
परिणाम:
{ "_id" : 2, "max" : [ 1 ] } { "_id" : 3, "max" : "1" } { "_id" : 4, "max" : "Two" } { "_id" : 5, "max" : ISODate("2000-01-03T23:30:15.100Z") } { "_id" : 6, "max" : ISODate("1999-01-03T23:30:15.100Z") }
_id
. वाला दस्तावेज़ का 2
, सरणियाँ संख्याओं से बड़ी होती हैं, इसलिए सरणी वापस आ जाती है (भले ही इसका तत्व एक संख्या है जो कुछ अन्य संख्याओं से कम है)।
दस्तावेज़ 3:स्ट्रिंग्स संख्याओं से बड़ी होती हैं, और इसलिए स्ट्रिंग वापस आ जाती है।
दस्तावेज़ 4:सभी फ़ील्ड स्ट्रिंग हैं, और इसलिए Two
सबसे बड़ी स्ट्रिंग है।
दस्तावेज़ 5:दो तिथियों की आपूर्ति की जाती है, और इसलिए बाद की तारीख वापस कर दी जाती है।
दस्तावेज़ 6:इस मामले में, दिनांक वस्तु और दिनांक स्ट्रिंग की आपूर्ति की जाती है। दिनांक ऑब्जेक्ट स्ट्रिंग से बड़े होते हैं, और इसलिए दिनांक ऑब्जेक्ट वापस कर दिया जाता है (भले ही इसकी तिथि स्ट्रिंग की तुलना में पहले हो)।
उपलब्ध चरण
$max
निम्नलिखित चरणों में उपलब्ध है:
$group
$project
$addFields
$set
$replaceRoot
$replaceWith
$match
चरण जिसमें एक$expr
. शामिल है अभिव्यक्ति