MongoDB queries operators (prefix చేయబడినవి $) ను ఉపయోగిస్తాయి సాధారణ సమానత్వం కంటే ఎక్కువ పరిస్థితులను వ్యక్తపరచడానికి — comparison, logical, element, మరియు array operators. ఇవి filter documents యొక్క నిర్మాణ విలువలు మీరు కోరిన డేటా కనుగొనడానికి.
db..({ : { : } });
db..({ : { : , : } });
db..({ : { : } });
db..({ : { : [, ] } });
db..({ : { : [] } });
$eq $ne → equal / not equal
$gt $gte → greater than / greater-or-equal
$lt $lte → less than / less-or-equal
$in $nin → in / not in a list of values
// $and / $or / $not / $nor combine conditions
db.users.find({ $or: [{ age: { $lt: 18 } }, { age: { $gt: 65 } }] }); // young OR old
db.users.find({ $and: [{ active: true }, { premium: true }] });
// (multiple fields in one filter are AND by default)
db.users.find({ active: true, age: { $gt: 18 } }); // active AND age > 18
Filter లో బహుళ fields అవ్యక్తంగా ANDed; $or/$and/$not మరింత సంక్లిష్ట logic ను వ్యక్తపరుస్తుంది.
db.users.find({ email: { $exists: true } }); // field exists
db.users.find({ age: { $type: "number" } }); // field is of a type
// array operators
db.posts.find({ tags: "mongodb" }); // array CONTAINS "mongodb"
db.posts.find({ tags: { $all: ["a", "b"] } }); // contains ALL of these
db.posts.find({ tags: { $size: 3 } }); // array has exactly 3 elements
db.posts.find({ "scores": { $elemMatch: { $gt: 80, $lt: 90 } } }); // an element matching
Array operators arrays లోపల query చేస్తాయి — $all (సన్నిహితంగా అన్నీ), $size (length), $elemMatch (బహుళ పరిస్థితులను సరిపోయే element), మరియు విలువ నేరుగా సరిపోయడం containment ను చెక్ చేస్తుంది.
db.users.find({ "address.city": "NY" }); // query a NESTED field with dot notation
Query operators MongoDB లో ఫలప్రభంగా డేటా ఫిల్టర్ చేయడానికి అవసరమైనవి — నిర్దిష్ట documents ను పరిస్థితుల ఆధారంగా కనుగొనడం ఏదైనా అనువర్తనంలో స్థిరమైన అవసరం, కాబట్టి వాటిని అర్థం చేసుకోవడం ప్రాథమిక రోజువారీ జ్ఞానం.
Comparison operators ($gt, $lt, $in, మరియు ఇతరాలు ranges మరియు value matching కోసం), logical operators ($or, $and, మరియు బహుళ filter fields అవ్యక్తంగా AND-ed), element operators ($exists, $type), మరియు ముఖ్యంగా array operators ($all, $size, $elemMatch, మరియు నేరుగా containment matching) తెలుసుకోవడం మీకు అవసరమైన query conditions స్పెక్ట్రమ్ ను కవర్ చేస్తుంది.
Array operators MongoDB లో ప్రత్యేకంగా ముఖ్యమైనవి ఎందుకంటే documents సాధారణంగా arrays ను కలిగి ఉంటాయి (document model యొక్క కీ భాగం), మరియు వాటిలో query చేయడం (containment, all-elements, element-matching) MongoDB querying ను వేరు చేసే ఆచరణ అవసరం.
Nested fields ను query చేయడానికి dot notation అర్థం చేసుకోవడం ("address.city") MongoDB యొక్క nested document structure ఇచ్చిన ఇది అవసరం.
డేటా ఫిల్టర్ చేయడం అత్యంత సాధారణ database operations లో ఒకటి, మరియు MongoDB యొక్క query operators (comparison, logical, element, మరియు ముఖ్యంగా array operators, ప్లస్ nested-field querying) సరైన documents ను కనుగొనడానికి పరిస్థితులను వ్యక్తపరచడానికి మీరు ఎలా, అర్థం చేసుకోవడం ఆవశ్యక, తరచుగా-ఉపయోగించిన MongoDB జ్ఞానం — SQL యొక్క WHERE conditions ను రూపొందించడానికి సమానమైనది, మరియు MongoDB యొక్క document మరియు array-rich డేటా వ్యతిరేక ప్రభావవంతమైన queries రాయడానికి అవసరం, ఏదైనా MongoDB development కోసం కోర్ నైపుణ్యం.