Theory
Raw Records से Answers तक
FestConnect का organiser हर event document पढ़ना नहीं चाहता; उन्हें ANSWERS चाहिए: 'मुझे 3 सबसे बड़े events दिखाओ', 'हर event के लिए कितने लोगों ने register किया', 'total seat capacity क्या है'। इन्हें एक plain find से ज़्यादा चाहिए: इन्हें SORTING, LIMITING, और grouping चाहिए।
यह lesson stored documents को insights में बदलने वाले tools के साथ MongoDB finish करता है: results को shape करने के लिए sort और limit, $inc जैसे precise update operators, और AGGREGATION pipeline, SQL के GROUP BY का MongoDB का powerful equivalent। यहीं database अपनी reporting के लिए keep कमाता है।
Theory
Sort, Limit, और Precise Updates
find पर chain करके reads shape करना:
.sort({ seats: -1 }): results order कीजिए: -1 descending, 1 ascending.limit(2): at most 2 return कीजिए.skip(n): पहले n skip कीजिए (paging के लिए)
तो find().sort({ seats: -1 }).limit(3) 3 सबसे बड़े events देता है।
$set से आगे operators के साथ precise updates:
$inc: एक number increment/decrement कीजिए:{ $inc: { seats: -1 } }एक seat books करता है$push: array में add कीजिए;$pull: array से remove कीजिए;$unset: एक field remove कीजिए
ये document का exactly एक aspect बदलते हैं बाकी को touch किए बिना, whole-document replacement का safe alternative।
Practical
Sort + Limit, $inc, और एक Aggregation
// Events: Garba 350, Coding 60, Webinar 500
// Top 2 events by seats (descending):
db.events.find({}, { name: 1, _id: 0 }).sort({ seats: -1 }).limit(2)
// -> { name: "Webinar" }, { name: "Garba Night" } (500, then 350)
// Book a seat: decrement with $inc
db.events.updateOne({ name: "Garba Night" }, { $inc: { seats: -1 } })
// Garba Night now has 349
// AGGREGATION: count registrations per event
db.registrations.aggregate([
{ $match: { paid: true } }, // stage 1: filter
{ $group: { _id: "$event", total: { $sum: 1 } } }, // stage 2: group + count
{ $sort: { total: -1 } } // stage 3: sort
])
// e.g. { _id: "Garba Night", total: 40 }, ...
This example runs in Gri-Learn on the web, where you can edit it and see the output.
Theory
Aggregation Pipeline
Aggregation documents को STAGES की एक ordered SEQUENCE से process करता है, हर एक stream को transform करते हुए जो अगले में flow करता है, एक factory line की तरह। Common stages:
- $match: documents filter कीजिए (find की तरह)
- $group: एक field से group कीजिए और AGGREGATES compute कीजिए:
$sum,$avg,$max, counts - $sort, $project, $limit: order, reshape, cap कीजिए
ऊपर का example paid registrations में filter करता है ($match), इन्हें event से group करता है और हर group को count करता है ($group with $sum: 1), फिर count से sort करता है। Result: हर event के लिए registrations, सबसे popular पहले। यह SQL के GROUP BY का MongoDB का answer है, और stages का ORDER matter करता है: हर stage अगले को feed करता है।
Quiz
db.events.find().sort({ seats: -1 }) में, -1 क्या करता है?
- सिर्फ़ 1 document return करता है
- Results को seats से DESCENDING order में sort करता है (सबसे बड़ा पहले); 1 ascending होता
- seats field remove करता है
- Negative seats वाले documents delete करता है
Show the answer
Results को seats से DESCENDING order में sort करता है (सबसे बड़ा पहले); 1 ascending होता
sort() में, value 1 का मतलब ASCENDING है और -1 का मतलब DESCENDING, तो sort({ seats: -1 }) events को seats से सबसे बड़े से सबसे छोटे order करता है। Option A sort को limit(1) से confuse करता है। Option C इसे projection से confuse करता है (seats: 0 field exclude करता)। Option D एक delete operation invent करता है। Sort convention याद रखिए: 1 up, -1 down: यह एक frequent exam और real-world detail है (इसे उल्टा करना silently results को ग़लत order में return करता है)। 'Top N' पाने के लिए sort को limit से combine कीजिए: descending sort कीजिए, फिर limit कीजिए।
Think first
Aggregation एक Pipeline of Stages क्यों है?
Aggregation $match, फिर $group, फिर $sort separate ordered stages की तरह चलाता है। एक बड़ी query की बजाय इसे इस तरह structure क्यों करें, और क्या order matter करता है? फिर tap कीजिए।
Show the answer
Pipeline structure हर stage को ONE transformation करने और इसका output अगले को pass करने देता है, एक assembly line की तरह: documents filter कीजिए ($match), फिर जो survive किया उसे group और summarise कीजिए ($group), फिर summary order कीजिए ($sort)। यह complex data processing को readable और composable बनाता है: आप एक बड़ी transformation छोटे, understandable steps से build करते हैं। और ORDER absolutely matter करता है: $match FIRST ($group से पहले) early filter करता है तो आप fewer documents group करते हैं (efficient और correct); $group से पहले $sort लगाना ग़लत चीज़ sort करता। Stages reorder करना result AND performance दोनों बदलता है। इसे एक factory line की तरह सोचिए: raw documents in, हर stage refine करता है, answer end से आता है। Stages को उस order में design कीजिए जिस order में data को flow करना चाहिए।
Watch out
Operator और Aggregation Traps
Sort Direction Backwards: -1 descending है, 1 ascending; ग़लत करना silently results reorder करता है।
Counters के लिए $inc बनाम $set: number को इसके current value से relative बदलने के लिए $inc इस्तेमाल कीजिए (एक seat book करना); $set के लिए आपको exact नई value जाननी पड़ेगी।
Aggregation Stage Order: $group से पहले $match (early filter कीजिए); order results बदलता है।
$group में Field Names पर $ भूलना: "$event" (with $) से group कीजिए, "event" से नहीं।
Find-Chaining को Aggregation से Confuse करना: sort/limit find पर chain होते हैं; $group सिर्फ़ aggregate() में exist करता है।
Theory
Unit 1 Complete: The Modern Data Layer
FestConnect के पास अब एक full NoSQL data layer है: collections में documents, complete CRUD, query और projection operators, result shaping, और reporting के लिए aggregation। यह modern web stack का DATA half है। Unit 2 React के साथ UI half build करता है: components, props, state, events, forms और hooks, तो FestConnect को इस MongoDB back-end पर बैठा एक modern, reactive front-end मिलता है। Data से interface तक।
Summary
Key takeaways
- Chaining से reads shape कीजिए: .sort({field: -1}) descending / 1 ascending, .limit(n) cap करता है, .skip(n) pages करता है।
- find().sort({seats:-1}).limit(3) seats से top 3 देता है।
- $set से आगे update operators: $inc (increment, जैसे एक seat book करना), $push/$pull (array add/remove), $unset (field remove करना)।
- Aggregation documents को ordered STAGES से process करता है: $match (filter), $group (group + aggregate), $sort, $project, $limit।
- Accumulators ($sum, $avg, count) वाला $group MongoDB का GROUP BY है; $group से पहले $match रखिए।
- Stage order matter करता है: हर stage अगले को feed करता है, एक factory line की तरह।
- Memory hook: sort -1 down है, $inc counts करता है, aggregation stages की एक pipeline है।