MongoDBలో OR ఆపరేటర్‌ని ఎలా ఉపయోగించాలి
MongoDBలోని OR ఆపరేటర్ “$or” ఆకృతిలో సూచించబడుతుంది. లాజికల్ OR ఆపరేషన్ నిర్వహించబడే స్క్వేర్ బ్రాకెట్‌లలో బహుళ వ్యక్తీకరణలను జతచేయడానికి “$or” ఉపయోగించబడుతుంది. మేము MongoDB సేకరణలో $ లేదా ఆపరేటర్‌ని ఉపయోగిస్తాము. మేము 'రోగులు' పేరుతో MongoDB సేకరణను సృష్టిస్తాము. మేము $ లేదా ఆపరేటర్‌ని నిర్వహించే బహుళ పత్రాలతో “రోగుల” సేకరణ చొప్పించబడింది. ఇన్సర్ట్‌మేనీ() పద్ధతిని ప్రారంభించడం ద్వారా క్రింది పత్రాలు MongoDBలో చొప్పించబడ్డాయి:
db.Patients.insertMany ( [{
'మొదటి పేరు' : 'జెన్నిఫర్' ,
'చివరి పేరు' : 'జాషువా' ,
'వయస్సు' : 44 ,
'ఫోను నంబరు' : 43400517 ,
'అపాయింట్మెంట్' : 'దంతవైద్యుడు' ,
'ఛార్జీలు' : 2000 ,
'పరీక్ష' : [ 'ఎక్స్-రే' , 'రక్తం' , 'పుల్పాల్' ]
} ,
{
'మొదటి పేరు' : 'థామస్' ,
'చివరి పేరు' : 'స్టీవెన్' ,
'వయస్సు' : 74 ,
'ఫోను నంబరు' : 39034694 ,
'అపాయింట్మెంట్ తేదీ' : 'సర్జన్' ,
'ఛార్జీలు' : 6000 ,
'పరీక్ష' : [ 'ఎంపిక' , 'PPT' ]
} ,
{
'మొదటి పేరు' : 'చార్లెస్' ,
'చివరి పేరు' : 'డేనియల్' ,
'వయస్సు' : 35 ,
'ఫోను నంబరు' : 65712165 ,
'అపాయింట్మెంట్' : 'కార్డియాలజీ వైద్యుడు' ,
'ఛార్జీలు' : 2000 ,
'పరీక్ష' : [ 'CT' , 'MRI' ]
} ,
{
'మొదటి పేరు' : 'మిచెల్' ,
'చివరి పేరు' : 'పాల్' ,
'వయస్సు' : 51 ,
'ఫోను నంబరు' : 54399288 ,
'అపాయింట్మెంట్' : 'చర్మ వైద్యుడు' ,
'ఛార్జీలు' : 8000 ,
'పరీక్ష' : [ 'స్కిన్ బయాప్సీలు' , 'వుడ్ లైట్' , 'స్కిన్ స్క్రాపింగ్' ]
} ,
{
'మొదటి పేరు' : 'ఆండ్రూ' ,
'చివరి పేరు' : 'జెర్రీ' ,
'వయస్సు' : 69 ,
'ఫోను నంబరు' : 6108100 ,
'అపాయింట్మెంట్' : 'కార్డియాలజీ వైద్యుడు' ,
'ఛార్జీలు' : 7000 ,
'పరీక్ష' : [ 'ECG' , 'రక్తంలో చక్కెర స్థాయి' , 'అల్ట్రాసౌండ్' ]
}
] )
మునుపు చొప్పించిన పత్రాల అవుట్‌పుట్ “నిజం” అని గుర్తిస్తుంది మరియు ప్రతి పత్రానికి “ఇన్‌సర్టెడ్ ఐడి” విలువలను అందిస్తుంది.
ఉదాహరణ 1: MongoDB $OR పత్రాలను సరిపోల్చడానికి ఆపరేటర్
MongoDB $లేదా ఆపరేటర్ యొక్క ప్రాథమిక ప్రశ్న ఇక్కడ అమలు చేయబడింది, ఇది MongoDBలో ఈ ఆపరేటర్ యొక్క పనిని ప్రదర్శిస్తుంది. ఇక్కడ, మేము find() పద్ధతితో ప్రశ్నను నిర్వచించాము. $లేదా ఆపరేటర్‌తో ఫైండ్() పద్ధతి మరింతగా పేర్కొనబడింది. $ లేదా ఆపరేటర్ విలువలతో కేటాయించబడిన “అపాయింట్మెంట్” మరియు “ఛార్జీలు” అనే రెండు ఫీల్డ్‌లను తీసుకుంటారు. $ లేదా ఆపరేటర్ ఫీల్డ్ విలువతో సరిపోలుతుంది మరియు ఫీల్డ్ విలువలతో సరిపోలిన విలువలు ఉన్న పత్రాలను మాత్రమే తిరిగి పొందుతుంది. $ లేదా ఆపరేటర్ యొక్క ప్రశ్న నిర్మాణం కింది వాటిలో అందించబడింది:
db.Patients.find ( { $లేదా : [ { అపాయింట్మెంట్: 'చర్మ వైద్యుడు' } ,
{ ఛార్జీలు: 7000 } ] } ) .చక్కని ( )
'డెర్మటాలజిస్ట్' వద్ద 'అపాయింట్మెంట్' మరియు 'ఛార్జీలు' '7000' ఉన్న పత్రాలను మేము పొందుతాము. $లేదా ఆపరేటర్ రెండు ఫీల్డ్ విలువల నుండి నిజమైన ఫలితాలను కనుగొంటారు మరియు అవుట్‌పుట్‌లో సరిపోలిన పత్రాలను తిరిగి అందిస్తారు.
ఉదాహరణ 2: MongoDB $OR ఉనికిలో లేని పత్రాలను సరిపోల్చడానికి ఆపరేటర్
$లేదా ఆపరేటర్ యొక్క మునుపటి ప్రశ్నలో, మేము సరిపోలిన పత్రాలను పొందాము. ఇప్పుడు, మేము 'రోగి' సేకరణ నుండి ఉనికిలో లేని పత్రాన్ని తిరిగి పొందుతాము. కింది $లేదా ఆపరేటర్ ప్రశ్న 'మొదటి పేరు' 'చార్లెస్' మరియు 'అపాయింట్మెంట్' 'వైద్యుని' వద్ద ఉన్న పత్రాన్ని తీసుకుంటుంది. $లేదా ఆపరేటర్ 'పేషెంట్స్' సేకరణలోని ఈ ఫీల్డ్ విలువలతో సరిపోలుతుంది మరియు సరిపోలిన తర్వాత ఫలితాలను రూపొందిస్తుంది.
db.Patients.find ( { $లేదా : [ { 'మొదటి పేరు' : 'చార్లెస్' } , { 'అపాయింట్మెంట్' : 'వైద్యుడు' } ] } ) .చక్కని ( )
$లేదా ఆపరేటర్‌కు ఒక నిజమైన ఫలితం ఉంది మరియు మరొకటి తప్పుడు ఫలితాన్ని కలిగి ఉంది. 'రోగి' సేకరణలోని ఏ డాక్యుమెంట్‌లతో సరిపోలని 'వైద్యుడు' విలువతో 'అపాయింట్మెంట్'ని మేము పేర్కొన్నాము. అందుకే, $లేదా ఆపరేటర్ సరిపోలిన ఫీల్డ్ యొక్క డాక్యుమెంట్‌ను మాత్రమే అవుట్‌పుట్‌గా 'పేషెంట్'గా తిరిగి అందిస్తారు.
ఉదాహరణ 3: MongoDB $OR బహుళ వాదనలతో ఆపరేటర్
మేము మునుపటి $లేదా ఆపరేటర్ ప్రశ్నలలో రెండు ఆర్గ్యుమెంట్‌లను అందించాము. ఇక్కడ, మేము $ లేదా ఆపరేటర్ వ్యక్తీకరణగా రెండు కంటే ఎక్కువ ఆర్గ్యుమెంట్‌లను పాస్ చేస్తాము. మేము దానికి ఇచ్చిన 'వయస్సు' ఫీల్డ్ విలువలలో దేనికైనా సరిపోలే పత్రాన్ని తిరిగి పొందుతాము. ఎక్స్‌ప్రెషన్‌లలో ఒకటి నిజం కావాలనే బహుళ వాదనలకు $లేదా ఆపరేటర్ అవసరం ఒకే విధంగా ఉంటుంది. $లేదా ఆపరేటర్‌లో బహుళ ఆర్గ్యుమెంట్‌ల కోసం ప్రశ్న క్రింది విధంగా ఇవ్వబడింది:
db.Patients.find ( { 'అపాయింట్మెంట్' : 'కార్డియాలజీ వైద్యుడు' , $లేదా : [ { 'వయస్సు' : ఇరవై } , { 'వయస్సు' : 35 } , { 'వయస్సు' : 69 } ] } )అక్కడ, మేము $ లేదా ఆపరేటర్ నుండి పొందిన రెండు సరిపోలిన ఫలితాలను కలిగి ఉన్నాము. “35” మరియు “69” ఉన్న “వయస్సు” విలువలు $ లేదా ఆపరేటర్ ద్వారా పొందబడిన మరియు షెల్‌పై ప్రదర్శించబడే “రోగుల” పత్రాలతో పోల్చబడ్డాయి.
ఉదాహరణ 4: మొంగోడిబి $OR అగ్రిగేషన్‌తో ఆపరేటర్
మొంగోడిబిలోని మొత్తం పద్ధతి రికార్డులను సేకరణగా మిళితం చేస్తుంది. అందువలన, వారు వివిధ కార్యకలాపాలకు ఉపయోగించవచ్చు. మేము $లేదా ఆపరేటర్‌ను అగ్రిగేషన్ పద్ధతిలో నిర్వహిస్తాము, ఇది ఒకటి లేదా అంతకంటే ఎక్కువ వ్యక్తీకరణలను మూల్యాంకనం చేస్తుంది మరియు వాటిలో ఏదైనా సరే అని మూల్యాంకనం చేస్తే నిజమైనదిగా చూపుతుంది. లేకపోతే, ప్రకటన తప్పుగా పరిగణించబడుతుంది.
$లేదా అగ్రిగేషన్ ఆపరేటర్ క్వెరీని కలిగి ఉన్నాము, ఇక్కడ మేము మొదట అగ్రిగేట్() పద్ధతిని అమలు చేస్తాము, ఆ తర్వాత $match మరియు $projectని పత్రం నుండి సరిపోల్చాల్సిన _id విలువతో పేర్కొనబడుతుంది. అప్పుడు, మేము 'వయస్సు' ఫీల్డ్‌ను '1' విలువతో సెట్ చేస్తాము ఎందుకంటే ఈ ఫీల్డ్ అన్ని డాక్యుమెంట్‌ల నుండి మాత్రమే రూపొందించబడాలని మేము కోరుకుంటున్నాము. ఆ తర్వాత, మేము $ లేదా ఆపరేషన్‌ని కలిగి ఉన్న “ఫలితాలు” లక్షణాన్ని నిర్వచించాము. $లేదా ఆపరేటర్ $gt యొక్క షరతులతో కూడిన ప్రకటనను తీసుకుంటారు. “$gt:[“$Age”, 69]” వ్యక్తీకరణ “69” కంటే ఎక్కువ విలువ ఉన్న వయస్సును ఇస్తుంది. ఈ వ్యక్తీకరణ యొక్క ఫలితాలు $ లేదా ఆపరేటర్‌కు పంపబడతాయి మరియు $ లేదా ఆపరేటర్ పేర్కొన్న షరతుకు అనుగుణంగా ఉన్న పత్రాన్ని తిరిగి అందజేస్తారు.
db.Patients.మొత్తం ([
{ $ మ్యాచ్ : { _id: ObjectId ( '6391c61a4c91e007fb4f0228' ) } } ,
{ $ప్రాజెక్ట్ : {
_id: ObjectId ( '6391c61a4c91e007fb4f0227' ) ,
వయస్సు: ఒకటి ,
ఫలితం: { $లేదా : [
{ $gt : [ ' $వయస్సు ' , 69 ] }
] }
}
}
]
)
“69” కంటే ఎక్కువ ఉన్న “వయస్సు” “74”, ఇది “నిజమైన” విలువను కలిగి ఉన్న “ఫలితాలు”తో పాటు అవుట్‌పుట్ షెల్‌లో ప్రదర్శించబడుతుంది.
ఉదాహరణ 5: MongoDB $OR ఆపరేటర్ షరతులను ప్రేరేపిస్తుంది
MongoDB యొక్క $ లేదా ఆపరేటర్ లాజికల్ ఆపరేటర్. మేము ఈ లాజికల్ ఆపరేటర్‌ని షరతులతో కూడిన ఆపరేటర్‌తో ఉపయోగించవచ్చు. షరతులు సంతృప్తి చెందినప్పుడు $ లేదా ఆపరేటర్ ఫలితాలను అందిస్తుంది. అదనంగా, మేము $ లేదా ఆపరేటర్‌లో ఒకటి కంటే ఎక్కువ షరతులను అమలు చేయవచ్చు, వాటిలో ఒకటి తప్పక నిజం. ఇక్కడ, మేము రెండు వేర్వేరు షరతులతో పేర్కొనబడిన $ లేదా ఆపరేటర్ యొక్క ప్రశ్నను కలిగి ఉన్నాము. మొదటి షరతు “{ఛార్జీలు:{$lt: 6000}}” ఇది “6000” విలువ కంటే తక్కువ “ఛార్జీలు” ఉన్న పత్రాన్ని అందిస్తుంది. {ఛార్జీలు:'$gt: 7000'} షరతు '7000' విలువ 'ఛార్జీలు' కంటే ఎక్కువ పత్రాన్ని పొందుతుంది.
ఈ షరతులు సంతృప్తి చెందినప్పుడు $లేదా ఆపరేటర్ సరిపోలిన పత్రాన్ని అందిస్తారు. ఆపై, $ లేదా ఆపరేటర్ సరిపోలిన పత్రాన్ని ఇచ్చినప్పుడు మాత్రమే చూపబడే ఫీల్డ్‌ల పేర్లను మేము నిర్దేశిస్తాము.
db.Patients.find ( {$లేదా : [
{ ఛార్జీలు: { $lt : 6000 } } ,
{ ఛార్జీలు: { $gt : 7000 } }
]
} , {
మొదటి పేరు: ఒకటి ,
ఛార్జీలు: ఒకటి
} )
సరిపోలిన డాక్యుమెంట్‌ల కోసం అవుట్‌పుట్ “ఫస్ట్ నేమ్” మరియు “ఛార్జీలు” ఫీల్డ్‌లను మాత్రమే ప్రదర్శిస్తుంది.
ఉదాహరణ 6: మొంగోడిబి $OR ఆర్గ్యుమెంట్ లేని ఆపరేటర్
$ లేదా ఆపరేటర్‌తో అమలు చేయబడిన అన్ని ప్రశ్నలు ఆర్గ్యుమెంట్ విలువతో పాస్ చేయబడ్డాయి. ఇప్పుడు, మేము ఆర్గ్యుమెంట్ లేని $ లేదా ఆపరేటర్ ప్రశ్నను నిర్వచించాము. ఖాళీ వాదన $ లేదా ఆపరేటర్ ప్రశ్న అమలు చేయబడినప్పుడు, అది తప్పుడు ఫలితాలను మూల్యాంకనం చేస్తుంది. ఖాళీ వ్యక్తీకరణతో $ లేదా ఆపరేషన్ ఎక్కడ పాస్ చేయబడిందో మేము ప్రశ్నను అందిస్తాము.
db.Patients.మొత్తం ([
{ $ మ్యాచ్ : { _id: { $in : [ ఆబ్జెక్ట్ ఐడి ( '6391c61a4c91e007fb4f0228' ) ] } } } ,
{ $ప్రాజెక్ట్ : {
_id: ObjectId ( '6391c61a4c91e007fb4f0227' ) ,
ఫలితం: { $లేదా : [ ] } }
}
]
)
ఫలితంగా $లేదా ఆపరేటర్‌కు ఖాళీ వాదన అందించబడింది, ఫలితాలు తప్పుడు విలువను సూచిస్తాయి.
ఉదాహరణ 7: MongoDB $OR ఆపరేటర్ అర్రే విలువలతో సరిపోలుతుంది
మేము విభిన్న విలువలను కలిగి ఉన్న పత్రాలలో 'పరీక్ష' శ్రేణిని ఇన్సర్ట్ చేస్తాము. మేము ఫలితాలను పరిశీలించడానికి $ లేదా ఆపరేటర్ కోసం ఆ శ్రేణిని ఉపయోగిస్తాము. కింది ప్రశ్నలోని $లేదా ఆపరేటర్‌ను find() పద్ధతిలో అమలు చేస్తారు. $లేదా ఆపరేటర్ 'పరీక్ష' శ్రేణిని వ్యక్తీకరణగా తీసుకుంటారు. శ్రేణిలోని 'MRI' మరియు 'CT' విలువలతో సరిపోలే ఫీల్డ్ విలువలను గుర్తించడానికి 'టెస్ట్' శ్రేణి $in ఆపరేటర్‌ని ఉపయోగిస్తుంది.
db.Patients.find ( { $లేదా : [ { పరీక్ష: { $in : [ 'MRI' , 'CT' ] } } ] } ) .చక్కని ( )$లేదా క్వెరీ ఆపరేటర్‌ని అమలు చేసినప్పుడు షెల్‌పై ఒక పత్రం ప్రదర్శించబడుతుంది, ఇది తిరిగి పొందిన పత్రం పేర్కొన్న శ్రేణి విలువలను కలిగి ఉందని చూపుతుంది.
ముగింపు
ఈ MongoDB కథనం రెండు లేదా అంతకంటే ఎక్కువ వ్యక్తీకరణలను కలిగి ఉన్న శ్రేణిలో లాజికల్ OR ఆపరేషన్‌లను అమలు చేయడానికి అలాగే కనీసం ఒక వ్యక్తీకరణకు సరిపోలే పత్రాలను తిరిగి పొందడానికి MongoDB $ లేదా ఆపరేటర్ ప్రశ్నను ఉపయోగిస్తుంది. విభిన్న కార్యకలాపాలను నిర్వహించడానికి $ లేదా ఆపరేటర్‌ను MongoDB షెల్‌లో ప్రశ్నించడం జరిగింది. షరతులతో కూడిన ఆపరేటర్‌లలో $లేదా ఆపరేటర్ వ్యక్తీకరణగా ఉపయోగించబడుతుంది మరియు షరతులతో కూడిన స్టేట్‌మెంట్‌ల ఆధారంగా పత్రాలను అందిస్తుంది.