మన SQL స్టేట్‌మెంట్‌లలో AND ఆపరేటర్ ఎలా ఆడుతుందో చూద్దాం.
SQL మరియు ఆపరేటర్
మీరు ఊహించినట్లుగా, AND ఆపరేటర్ అనేది లాజికల్ ఆపరేటర్, ఇది రెండు లేదా అంతకంటే ఎక్కువ బూలియన్ వ్యక్తీకరణలను కలపడానికి మరియు వాటిని ఒకటిగా పరిగణించడానికి మిమ్మల్ని అనుమతిస్తుంది. షరతును వర్తింపజేయడానికి అన్ని షరతులు ఖచ్చితంగా ఉండాలి అని దీని అర్థం.
మీరు SELECT, UPDATE మరియు DELETE వంటి ఇతర SQL స్టేట్‌మెంట్‌లతో కలిపి WHERE నిబంధనలో ఉపయోగించిన మరియు ఆపరేటర్‌ని కనుగొంటారు.
ఇది చర్య చేసే పరిధిని పరిమితం చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ఉదాహరణకు, DELETE స్టేట్‌మెంట్‌ని ఉపయోగించి, పేర్కొన్న షరతును సంతృప్తిపరిచే డేటా మాత్రమే తీసివేయబడిందని నిర్ధారించుకోవడానికి మీరు WHERE నిబంధన మరియు AND కీవర్డ్‌ని ఉపయోగించవచ్చు.
AND ఆపరేటర్ యొక్క వాక్యనిర్మాణం క్రింద చూపిన విధంగా వ్యక్తీకరించబడుతుంది:
bool_expr_1 మరియు bool_expr_2 మరియు bool_expr_3… మరియు bool_expr_N;
మీరు కోరుకున్నన్ని బూలియన్ వ్యక్తీకరణలను కలిగి ఉండవచ్చు. అయితే, పేర్కొన్న అన్ని ఎక్స్‌ప్రెషన్‌లు తప్పనిసరిగా నిజమని అంచనా వేయాలని గుర్తుంచుకోండి. ఒక వ్యక్తీకరణ తప్పు అయితే, మొత్తం ప్రకటన తప్పుగా పరిగణించబడుతుంది.
గమనిక: NULL విలువలు కూడా తప్పుగా పరిగణించబడతాయి.
ఉదాహరణ ఉపయోగం
దిగువ ప్రశ్నలలో చూపిన విధంగా మనకు నమూనా డేటా ఉందని అనుకుందాం:
డ్రాప్ చేయండి డేటాబేస్ IF ఉనికిలో ఉంది నమూనా బి;సృష్టించు డేటాబేస్ నమూనా బి;
వా డు నమూనా బి;
సృష్టించు పట్టిక డెవలపర్లు (
id INT AUTO_INCREMENT కాదు శూన్య ప్రాథమిక కీ ,
మొదటి పేరు వర్చర్ ( యాభై ) కాదు శూన్య ,
చివరి పేరు వర్చర్ ( యాభై ) ,
శాఖ వర్చర్ ( యాభై ) కాదు శూన్య ,
జీతం INT
) ;
చొప్పించు INTO డెవలపర్లు ( మొదటి పేరు , చివరి పేరు , శాఖ , జీతం )
విలువలు
( 'రోగన్' , 'ఎల్లిసన్' , 'ఆట' , 120000 ) ,
( 'అన్నా' , 'నీల్' , 'డేటాబేస్' , 122000 ) ,
( 'ఫ్రేజర్' , 'ఎలా' , 'ముందుభాగం' , 100000 ) ,
( 'క్రిష్' , 'పొలార్డ్' , 'బ్యాకెండ్' , 115000 ) ,
( 'పని' , 'ఫోర్డ్' , 'డెవోప్స్' , 118000 ) ,
( 'సముద్రపు ఒడ్డు' , 'సా' , 'ఆట' , 135000 ) ,
( 'కైరా' , 'డీకన్' , 'డేటాబేస్' , 130000 ) ,
( 'ఆహ్వానించబడింది' , 'హాన్సన్' , 'మేఘం' , 123000 ) ,
( 'బొగ్దాన్' , 'మోర్లే' , 'ముందుభాగం' , 108000 ) ,
( 'మరియా' , 'గోల్డ్ స్మిత్' , 'బ్యాకెండ్' , 120000 ) ;
ఫలిత పట్టిక:
'devops' విభాగంలో పనిచేస్తున్న డెవలపర్‌లను కనుగొనడానికి మరియు 110000 కంటే ఎక్కువ జీతం కలిగి ఉండటానికి, మేము చూపిన విధంగా ప్రశ్నను అమలు చేయవచ్చు:
ఎంచుకోండి * నుండి డెవలపర్లు ఎక్కడ శాఖ = 'డెవోప్స్' మరియు జీతం >= 110000 ;ప్రశ్న సరిపోలే రికార్డులను కనుగొని, చూపిన విధంగా వాటిని తిరిగి ఇవ్వాలి:
id | మొదటి పేరు | చివరి పేరు | శాఖ | జీతం |--+----------+---------+------------+------+
5 | పని | ఫోర్డ్ | devops | 118000 |
ఈ సందర్భంలో, పైన చూపిన విధంగా ఒకే ఒక రికార్డు ఉంది. AND కీవర్డ్‌ని ఉపయోగించి మీ డేటాను ఫిల్టర్ చేయడానికి మీరు మరిన్ని షరతులను పేర్కొనవచ్చు.
ముగింపు
ఈ పోస్ట్‌లో, మీ ప్రశ్నలలో బహుళ బూలియన్ వ్యక్తీకరణలను కలపడానికి SQLలో AND ఆపరేటర్‌ని ఎలా ఉపయోగించాలో మేము చర్చించాము.
చదివినందుకు ధన్యవాదములు. OR ఆపరేటర్ గురించి మరింత తెలుసుకోవడానికి మరియు AND ఆపరేటర్‌తో పోలిస్తే ఇది ఎలా పని చేస్తుందో తెలుసుకోవడానికి మా SQL OR ఆపరేటర్ ట్యుటోరియల్‌ని తనిఖీ చేయండి.