Operators (Projection, update, limit(), sort()) and Aggregation commands

📖 Theory

કાચા records થી જવાબો સુધી

FestConnect ના આયોજકને દરેક event નું document વાંચવું નથી; એને જવાબો જોઈએ છે: '3 સૌથી મોટા events બતાવો', 'દરેક event માટે કેટલા લોકોએ નોંધણી કરાવી', 'કુલ બેઠકોની ક્ષમતા કેટલી છે'. આ માટે સાદા find કરતાં વધુ જોઈએ: ક્રમમાં ગોઠવવું, સંખ્યા મર્યાદિત કરવી અને જૂથમાં મૂકવું.

આ પાઠ MongoDB ને એવાં ઓજારો સાથે પૂરું કરે છે જે સંઘરેલાં documents ને સૂઝમાં ફેરવે છે: પરિણામોને ઘાટ આપવા sort અને limit, $inc જેવા ચોકસાઈભર્યા update ના operators, અને AGGREGATION ની pipeline, જે SQL ના GROUP BY નું MongoDB વાળું શક્તિશાળી રૂપ છે. અહીંથી જ database અહેવાલો બનાવવામાં પોતાનું મૂલ્ય સાબિત કરે છે.

📖 Theory

Sort, limit અને ચોકસાઈભર્યાં updates

વાચનને ઘાટ આપવો એટલે find ની પાછળ સાંકળ જોડવી:

• .sort({ seats: -1 }): પરિણામોનો ક્રમ: -1 એટલે ઊતરતો, 1 એટલે ચડતો
• .limit(2): વધુમાં વધુ 2 પાછાં આપે
• .skip(n): પહેલાં n છોડી દે (pages માટે)

એટલે find().sort({ seats: -1 }).limit(3) 3 સૌથી મોટા events આપે છે.

ચોકસાઈભર્યાં updates માટે $set ઉપરાંતના operators:

• $inc: સંખ્યા વધારે કે ઘટાડે: { $inc: { seats: -1 } } એક બેઠક bookings માં લે છે
• $push: array માં ઉમેરે; $pull: array માંથી કાઢે; $unset: field કાઢી નાખે

આ બધાં document ના બરાબર એક જ પાસાને બદલે છે અને બાકીનાને અડતાં નથી, એટલે આખું document બદલી નાખવા સામે એ સલામત વિકલ્પ છે.

⌨️ 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 ને તબક્કાંના ક્રમબદ્ધ સાંકળામાંથી પસાર કરે છે, અને દરેક તબક્કો પ્રવાહને બદલીને પછીના તબક્કા સુધી પહોંચાડે છે, જાણે કારખાનાની લાઇન. સામાન્ય તબક્કાં:

• $match: documents ગાળે (find ની જેમ)
• $group: કોઈ field પ્રમાણે જૂથ બનાવે અને સરવાળા કાઢે: $sum, $avg, $max, ગણતરીઓ
• $sort, $project, $limit: ક્રમ ગોઠવે, ઘાટ બદલે, સંખ્યા મર્યાદિત કરે

ઉપરનો દાખલો પહેલાં ચૂકવાયેલી registrations પૂરતું ગાળે છે ($match), પછી એમને event પ્રમાણે જૂથમાં મૂકીને દરેક જૂથ ગણે છે ($sum: 1 વાળું $group), પછી ગણતરી પ્રમાણે ક્રમ ગોઠવે છે. પરિણામ: event દીઠ registrations, સૌથી લોકપ્રિય પહેલાં. આ SQL ના GROUP BY નો MongoDB વાળો જવાબ છે, અને તબક્કાંનો ક્રમ અગત્યનો છે: દરેક તબક્કો પછીનાને ખવડાવે છે.

🧩 Quiz

db.events.find().sort({ seats: -1 }) માં -1 શું કરે છે?

1. ફક્ત 1 document પાછું આપે છે
2. પરિણામોને seats પ્રમાણે ઊતરતા ક્રમમાં ગોઠવે છે (સૌથી મોટું પહેલાં); 1 હોત તો ચડતો ક્રમ થાત
3. seats નું field કાઢી નાખે છે
4. ઋણ seats વાળાં documents ભૂંસી નાખે છે

💭 Think first

Aggregation તબક્કાંની pipeline કેમ છે?

Aggregation પહેલાં $match, પછી $group, પછી $sort એમ અલગ ક્રમબદ્ધ તબક્કાં ચલાવે છે. એક મોટી query ને બદલે આવું માળખું કેમ, અને ક્રમ અગત્યનો છે? વિચારીને પછી tap કરો.

⚠️ Watch out

Operator અને aggregation ના ફાંદા

Sort ની દિશા ઊલટી: -1 એટલે ઊતરતો, 1 એટલે ચડતો; ખોટું કરો તો પરિણામો ચૂપચાપ ફરી ગોઠવાઈ જાય છે.

ગણતરીઓ માટે $inc સામે $set: સંખ્યાને એની ચાલુ કિંમતના સંદર્ભે બદલવા $inc વાપરો (બેઠક book કરવી); $set માટે તમારે નવી ચોક્કસ કિંમત ખબર હોવી પડે.

Aggregation ના તબક્કાંનો ક્રમ: $group પહેલાં $match (વહેલી ગાળણી); ક્રમ બદલાય તો પરિણામ બદલાય છે.

$group માં field ના નામ પર $ ભૂલી જવું: "$event" પ્રમાણે જૂથ બનાવો ($ સાથે), "event" પ્રમાણે નહીં.

find ની સાંકળ અને aggregation ગૂંચવવાં: sort અને limit find ની પાછળ સાંકળમાં જોડાય છે; $group ફક્ત aggregate() માં જ હોય છે.

📖 Theory

Unit 1 પૂરું: આધુનિક data નું સ્તર

FestConnect પાસે હવે પૂરેપૂરું NoSQL વાળું data નું સ્તર છે: collections માંનાં documents, સંપૂર્ણ CRUD, query તથા projection ના operators, પરિણામોને ઘાટ આપવો, અને અહેવાલો માટે aggregation. આ આધુનિક web stack નો data વાળો અડધો ભાગ છે. Unit 2 React થી UI વાળો અડધો ભાગ બાંધે છે: components, props, state, events, forms અને hooks, જેથી આ MongoDB વાળા back-end પર બેઠેલું આધુનિક, પ્રતિભાવ આપતું front-end FestConnect ને મળે. Data થી આંતરમુખ સુધી.

✅ Summary

Key takeaways

• સાંકળ જોડીને વાચનને ઘાટ આપો: .sort({field: -1}) ઊતરતો ક્રમ અને 1 ચડતો ક્રમ, .limit(n) સંખ્યા મર્યાદિત કરે, .skip(n) pages માટે.
• find().sort({seats:-1}).limit(3) બેઠકો પ્રમાણે સૌથી ઉપરના 3 આપે છે.
• $set ઉપરાંતના update ના operators: $inc (વધારવું, જેમ કે બેઠક book કરવી), $push અને $pull (array માં ઉમેરવું કે કાઢવું), $unset (field કાઢવું).
• Aggregation documents ને ક્રમબદ્ધ તબક્કાંમાંથી પસાર કરે છે: $match (ગાળણી), $group (જૂથ અને સરવાળા), $sort, $project, $limit.
• સરવાળા કરતાં સાધનો ($sum, $avg, ગણતરી) સાથેનું $group એ MongoDB નું GROUP BY છે; $match ને $group પહેલાં મૂકો.
• તબક્કાંનો ક્રમ અગત્યનો છે: દરેક તબક્કો પછીનાને ખવડાવે છે, જાણે કારખાનાની લાઇન.
• યાદ રાખવાની કડી: sort માં -1 એટલે નીચે, $inc ગણતરી કરે, અને aggregation એ તબક્કાંની pipeline છે.