3.1 విలువలను పోల్చడం: <, >, =, <>
SQL ప్రశ్నలను వ్రాసేటప్పుడు ఉపయోగించే అత్యంత సాధారణ కీలక పదాలలో ఒకటి WHERE
. దీని సహాయంతో మనం MySQLకి ఏ టేబుల్ రోలను ఫిల్టర్ చేయాలనుకుంటున్నామో తెలియజేస్తాము (ఎంచుకోండి).
కీవర్డ్ తర్వాత, WHERE
మీరు చాలా క్లిష్టమైన మరియు గమ్మత్తైన పరిస్థితులను వ్రాయవచ్చు. కాబట్టి ఈ పరిస్థితి ఏ ఆపరేషన్లను కలిగి ఉంటుంది?
ఆపరేటర్ | వివరణ | ఉదాహరణ |
---|---|---|
< | తక్కువ | జీతం <40000 |
> | మరింత | జీతం > 100000 |
<= | తక్కువ లేదా సమానం | వయస్సు <= 25 |
>= | ఎక్కువ లేదా సమానం | వయస్సు >= 18 |
= | సమానం | occupation = 'ప్రోగ్రామర్' |
<>, != | సమానము కాదు | సంవత్సరం(join_date) != 2015 |
జావా భాష వలె కాకుండా, కఠినమైన సమానత్వం కోసం, ఇక్కడ ఒకటి సమాన అక్షరం ఉపయోగించబడుతుంది మరియు రెండు కాదు .
మీరు విలువలు సమానంగా లేవని తనిఖీ చేయాలనుకుంటే, ఇది రెండు విధాలుగా చేయవచ్చు: <>
మొదటి !=
విధానం పాస్కల్ వంటి భాషలలో ఉపయోగించబడుతుంది, రెండవది C ++ వంటి భాషలకు విలక్షణమైనది. మరియు జావా.
SQLలో అసైన్మెంట్ కోసం, ఇది పాస్కల్లో వలె ఉపయోగించబడుతుంది :=
, అయితే అసైన్మెంట్ చాలా అరుదుగా ఉపయోగించబడుతుంది.
2015లో నియమించబడని ఉద్యోగులందరినీ ప్రదర్శించే ప్రశ్నను వ్రాస్దాం.
SELECT * FROM employee WHERE YEAR(join_date) != 2015
మరియు మేము ఈ క్రింది ప్రశ్న ఫలితాన్ని పొందుతాము:
id | పేరు | వృత్తి | జీతం | వయస్సు | చేరుతున్న తేదీ |
---|---|---|---|---|---|
1 | ఇవనోవ్ ఇవాన్ | ప్రోగ్రామర్ | 100,000 | 25 | 2012-06-30 |
2 | పెట్రోవ్ పీటర్ | ప్రోగ్రామర్ | 80,000 | 23 | 2013-08-12 |
3 | ఇవనోవ్ సెర్గీ | టెస్టర్ | 40,000 | ముప్పై | 2014-01-01 |
6 | వాస్కా | పిల్లి | 1,000 | 3 | 2018-01-01 |
3.2 లాజికల్ కార్యకలాపాలు మరియు, లేదా, కాదు
మీరు తార్కిక WHERE
కార్యకలాపాలను కూడా ఉపయోగించవచ్చు AND
మరియు OR
. NOT
మరియు అవి నేను ఇక్కడ వివరించిన విధంగానే వ్రాయబడ్డాయి. ఏదీ లేదు &&
, ||
లేదా!
మేము 20 సంవత్సరాల కంటే ఎక్కువ వయస్సు ఉన్న మరియు 50K కంటే తక్కువ జీతం పొందే ఉద్యోగులను ఎంపిక చేసుకునే SQL ప్రశ్నను వ్రాస్దాం.
SELECT * FROM employee WHERE age > 20 AND salary < 50000
మరియు మేము ఈ క్రింది ప్రశ్న ఫలితాన్ని పొందుతాము:
id | పేరు | వృత్తి | జీతం | వయస్సు | చేరుతున్న తేదీ |
---|---|---|---|---|---|
3 | ఇవనోవ్ సెర్గీ | టెస్టర్ | 40,000 | ముప్పై | 2014-01-01 |
5 | కిరియెంకో అనస్తాసియా | ఆఫీసు మేనేజర్ | 40,000 | 25 | 2015-10-10 |
చాలా సులభం. 100K కంటే ఎక్కువ పొందే మరియు డైరెక్టర్గా పని చేయని ఉద్యోగులను ఎంచుకునే ప్రశ్నను వ్రాస్దాం:
SELECT * FROM employee WHERE salary >= 100000 AND NOT occupation = 'Director'
ఇక్కడ మేము ప్రత్యేకంగా గుర్తుకు బదులుగా !=
ఆపరేటర్ని ఉపయోగించాము NOT
.
మరియు మేము ఈ క్రింది ప్రశ్న ఫలితాన్ని పొందుతాము:
id | పేరు | వృత్తి | జీతం | వయస్సు | చేరుతున్న తేదీ |
---|---|---|---|---|---|
1 | ఇవనోవ్ ఇవాన్ | ప్రోగ్రామర్ | 100,000 | 25 | 2012-06-30 |
3.3 మధ్య: విలువ పరిధి
SQLలో ఒక ప్రత్యేక ఆపరేటర్ ఉంది, BETWEEN
దానితో మీరు రెండు విలువల మధ్య వేరియబుల్ ఉందో లేదో తనిఖీ చేయవచ్చు. ఈ ఆపరేటర్ బూలియన్ వ్యక్తీకరణలలో ఉపయోగించబడుతుంది. అటువంటి ఆపరేటర్ యొక్క సాధారణ రూపం:
variable BETWEEN bottom line AND top_bound
ఈ సందర్భంలో, జావా భాష వలె కాకుండా, దిగువ మరియు ఎగువ సరిహద్దులు రెండూ అనుమతించబడిన విరామంలో చేర్చబడతాయి.
మేము 40K నుండి 100K వరకు జీతంతో ఉద్యోగులందరినీ ఎంచుకునే ఉదాహరణ వ్రాస్దాం. అభ్యర్థన ఇలా కనిపిస్తుంది:
SELECT * FROM employee WHERE salary BETWEEN 40000 AND 100000
మరియు మేము ఈ క్రింది ప్రశ్న ఫలితాన్ని పొందుతాము:
id | పేరు | వృత్తి | జీతం | వయస్సు | చేరుతున్న తేదీ |
---|---|---|---|---|---|
1 | ఇవనోవ్ ఇవాన్ | ప్రోగ్రామర్ | 100,000 | 25 | 2012-06-30 |
2 | పెట్రోవ్ పీటర్ | ప్రోగ్రామర్ | 80,000 | 23 | 2013-08-12 |
3 | ఇవనోవ్ సెర్గీ | టెస్టర్ | 40,000 | ముప్పై | 2014-01-01 |
5 | కిరియెంకో అనస్తాసియా | ఆఫీసు మేనేజర్ | 40,000 | 25 | 2015-10-10 |
ఆపరేటర్ BETWEEN
సంఖ్యా రకాలను మాత్రమే కాకుండా, తేదీలు మరియు స్ట్రింగ్ రకాలను కూడా సపోర్ట్ చేస్తుంది . తీగలతో పని చేసే సందర్భంలో, లెక్సికోగ్రాఫిక్ ఆర్డర్ ఉపయోగించబడుతుంది: aaba aabb కంటే ముందు వస్తుంది
3.4 IN: విలువల జాబితా
అదనంగా, SQL ప్రత్యేక ఆపరేటర్ని కలిగి ఉంది, IN
దానితో మీరు పేర్కొన్న జాబితాలో వేరియబుల్ ఉందో లేదో తనిఖీ చేయవచ్చు. ఈ ఆపరేటర్ బూలియన్ వ్యక్తీకరణలలో ఉపయోగించబడుతుంది. అటువంటి ఆపరేటర్ యొక్క సాధారణ రూపం:
variable IN (value 1 , value 2 , ... value N)
మేము 20, 25 లేదా 30 సంవత్సరాల వయస్సు గల ఉద్యోగులను ఎంచుకునే ప్రశ్నను వ్రాస్దాం. అభ్యర్థన ఇలా కనిపిస్తుంది:
SELECT * FROM employee WHERE age IN (20, 25, 30)
మరియు మేము ఈ క్రింది ప్రశ్న ఫలితాన్ని పొందుతాము:
id | పేరు | వృత్తి | జీతం | వయస్సు | చేరుతున్న తేదీ |
---|---|---|---|---|---|
1 | ఇవనోవ్ ఇవాన్ | ప్రోగ్రామర్ | 100,000 | 25 | 2012-06-30 |
3 | ఇవనోవ్ సెర్గీ | టెస్టర్ | 40,000 | ముప్పై | 2014-01-01 |
5 | కిరియెంకో అనస్తాసియా | ఆఫీసు మేనేజర్ | 40,000 | 25 | 2015-10-10 |
మరియు ఇప్పుడు ఒక ప్రశ్నను వ్రాస్దాము, దానికి విరుద్ధంగా, మేము not
20, 25 లేదా 30 సంవత్సరాల వయస్సు గల ఉద్యోగులను ఎంచుకుంటాము. ప్రశ్న ఇలా కనిపిస్తుంది:
SELECT * FROM employee WHERE age NOT IN (20, 25, 30)
మరియు మేము ఈ క్రింది ప్రశ్న ఫలితాన్ని పొందుతాము:
id | పేరు | వృత్తి | జీతం | వయస్సు | చేరుతున్న తేదీ |
---|---|---|---|---|---|
2 | పెట్రోవ్ పీటర్ | ప్రోగ్రామర్ | 80,000 | 23 | 2013-08-12 |
4 | రాబినోవిచ్ మోయిషా | దర్శకుడు | 200,000 | 35 | 2015-05-12 |
6 | వాస్కా | పిల్లి | 1,000 | 3 | 2018-01-01 |
అంతా అనుకున్నట్లుగానే జరిగింది. అందం.
3.5 ఇష్టం: స్ట్రింగ్ నమూనా
చివరకు, మరొక ముఖ్యమైన మరియు చాలా తరచుగా ఉపయోగించే ఆపరేటర్ - LIKE
. తీగలను పోల్చినప్పుడు ఇది ఉపయోగించబడుతుంది. ఇది స్ట్రింగ్ నమూనాను సెట్ చేయడానికి ఉపయోగించవచ్చు. ఈ ఆపరేటర్ బూలియన్ వ్యక్తీకరణలలో ఉపయోగించబడుతుంది. అటువంటి ఆపరేటర్ యొక్క సాధారణ రూపం:
variable LIKE 'sample'
నమూనాలో ప్రత్యేక అక్షరాలను ఉపయోగించవచ్చు: %
మరియు _
.
- అండర్స్కోర్ అంటే ఏదైనా అక్షరం, ఎల్లప్పుడూ 1 pc.
- శాతం అంటే ఏదైనా అక్షరం మరియు ఎన్ని సార్లు అయినా (0 సార్లు సహా).
"I" అనే అక్షరంతో చివరి పేరు ప్రారంభమయ్యే వ్యక్తులందరినీ ఎంపిక చేసే ప్రశ్నను వ్రాద్దాం. అభ్యర్థన ఇలా కనిపిస్తుంది:
SELECT * FROM employee WHERE name LIKE 'I%'
మరియు మేము ఈ క్రింది ప్రశ్న ఫలితాన్ని పొందుతాము:
id | పేరు | వృత్తి | జీతం | వయస్సు | చేరుతున్న తేదీ |
---|---|---|---|---|---|
1 | ఇవనోవ్ ఇవాన్ | ప్రోగ్రామర్ | 100,000 | 25 | 2012-06-30 |
3 | ఇవనోవ్ సెర్గీ | టెస్టర్ | 40,000 | ముప్పై | 2014-01-01 |
ఇప్పుడు పనిని క్లిష్టతరం చేద్దాం - పేరులో "o" ఉండాలి మరియు పేరు "a" తో ముగియాలి. అభ్యర్థన ఇలా కనిపిస్తుంది:
SELECT * FROM employee WHERE name LIKE '%o%a'
మరియు మేము ఈ క్రింది ప్రశ్న ఫలితాన్ని పొందుతాము:
id | పేరు | వృత్తి | జీతం | వయస్సు | చేరుతున్న తేదీ |
---|---|---|---|---|---|
4 | రాబినోవిచ్ మోయిషా | దర్శకుడు | 200,000 | 35 | 2015-05-12 |
సరే, కొంచెం కష్టతరం చేద్దాం. "3" సంఖ్యతో వయస్సు ప్రారంభమయ్యే ఉద్యోగులందరినీ ఫిల్టర్ చేద్దాం. అభ్యర్థన ఇలా కనిపిస్తుంది:
SELECT * FROM employee WHERE age LIKE '3%'
మరియు మేము ఈ క్రింది ప్రశ్న ఫలితాన్ని పొందుతాము:
id | పేరు | వృత్తి | జీతం | వయస్సు | చేరుతున్న తేదీ |
---|---|---|---|---|---|
3 | ఇవనోవ్ సెర్గీ | టెస్టర్ | 40,000 | ముప్పై | 2014-01-01 |
4 | రాబినోవిచ్ మోయిషా | దర్శకుడు | 200,000 | 35 | 2015-05-12 |
6 | వాస్కా | పిల్లి | 1,000 | 3 | 2018-01-01 |
మార్గం ద్వారా, మా వయస్సు కాలమ్ రకం int
, కాబట్టి LIKE
ఇది స్ట్రింగ్లతో మాత్రమే పని చేస్తుంది. ఏం సంతోషించకుండా ఉండలేము.