SQLలో డేటా పోలిక అనేది ప్రతి డేటాబేస్ డెవలపర్ అప్పుడప్పుడు చూసే ఒక సాధారణ పని. అదృష్టవశాత్తూ, డేటా పోలిక అక్షర పోలిక, బూలియన్ పోలిక మొదలైన అనేక రకాల ఫార్మాట్‌లలో వస్తుంది.
అయితే, మీరు ఎదుర్కొనే వాస్తవ-ప్రపంచ డేటా పోలిక దృశ్యాలలో ఒకటి రెండు పట్టికల మధ్య పోలిక. డేటా ధ్రువీకరణ, దోష గుర్తింపు, నకిలీ లేదా డేటా సమగ్రతను నిర్ధారించడం వంటి పనులలో ఇది కీలక పాత్ర పోషిస్తుంది.
ఈ ట్యుటోరియల్‌లో, SQLలో రెండు డేటాబేస్ పట్టికలను సరిపోల్చడానికి మేము ఉపయోగించే అన్ని వివిధ పద్ధతులు మరియు సాంకేతికతలను మేము అన్వేషిస్తాము.
నమూనా డేటా సెటప్
మేము ప్రతి పద్ధతుల్లోకి ప్రవేశించే ముందు, ప్రదర్శన ప్రయోజనాల కోసం ప్రాథమిక డేటా సెటప్‌ను సెటప్ చేద్దాం.
ఉదాహరణలో చూపిన విధంగా నమూనా డేటాతో మాకు రెండు పట్టికలు ఉన్నాయి.
నమూనా పట్టిక 1:
కింది వాటిలో మొదటి పట్టికను సృష్టించడం మరియు పట్టికలో నమూనా డేటాను చొప్పించడం కోసం ప్రశ్నలు ఉన్నాయి:
పట్టిక నమూనా_tb1ని సృష్టించండి (
ఉద్యోగి_ఐడి INT ప్రాథమిక కీ AUTO_INCREMENT,
మొదటి_పేరు VARCHAR ( యాభై ) ,
చివరి_పేరు VARCHAR ( యాభై ) ,
శాఖ VARCHAR ( యాభై ) ,
జీతం DECIMAL ( 10 , 2 )
) ;
నమూనా_tb1లోకి చొప్పించండి ( మొదటి_పేరు, చివరి_పేరు, విభాగం, జీతం )
విలువలు
( 'పెనెలోప్' , 'ఛేజ్' , 'HR' , 55000.00 ) ,
( 'మాథ్యూ' , 'కేజ్' , 'ఐటీ' , 60000.00 ) ,
( 'జెనిఫర్' , 'డేవిస్' , 'ఫైనాన్స్' , 50000.00 ) ,
( 'కిర్స్టన్' , 'ఫాసెట్' , 'ఐటీ' , 62000.00 ) ,
( 'కామెరూన్' , 'కాస్ట్నర్' , 'ఫైనాన్స్' , 48000.00 ) ;
ఇది పేర్లు, విభాగం మరియు జీతం వంటి వివిధ సమాచారంతో “sample_tb1” అనే కొత్త పట్టికను సృష్టించాలి.
ఫలిత పట్టిక క్రింది విధంగా ఉంది:
నమూనా పట్టిక 2:
మనం కొనసాగి, రెండు నమూనా పట్టికలను రూపొందిద్దాం. ఇది మొదటి పట్టిక యొక్క బ్యాకప్ కాపీ అని భావించండి. కింది వాటిలో చూపిన విధంగా మేము పట్టికను సృష్టించి, నమూనా డేటాను చొప్పించవచ్చు:
పట్టిక నమూనా_tb2ని సృష్టించండి (ఉద్యోగి_ఐడి INT ప్రాథమిక కీ AUTO_INCREMENT,
మొదటి_పేరు VARCHAR ( యాభై ) ,
చివరి_పేరు VARCHAR ( యాభై ) ,
శాఖ VARCHAR ( యాభై ) ,
జీతం DECIMAL ( 10 , 2 )
) ;
నమూనా_tb2లోకి చొప్పించండి ( మొదటి_పేరు, చివరి_పేరు, విభాగం, జీతం )
విలువలు
( 'పెనెలోప్' , 'ఛేజ్' , 'HR' , 55000.00 ) ,
( 'మాథ్యూ' , 'కేజ్' , 'ఐటీ' , 60000.00 ) ,
( 'జెనిఫర్' , 'డేవిస్' , 'ఫైనాన్స్' , 50000.00 ) ,
( 'కిర్స్టన్' , 'ఫాసెట్' , 'ఐటీ' , 62000.00 ) ,
( 'ఆడ్రీ' , 'డీన్' , 'ఫైనాన్స్' , 48000.00 ) ;
ఇది ఒక పట్టికను సృష్టించి, మునుపటి ప్రశ్నలో పేర్కొన్న విధంగా నమూనా డేటాను చొప్పించాలి. ఫలిత పట్టిక క్రింది విధంగా ఉంది:
మినహా ఉపయోగించి రెండు పట్టికలను సరిపోల్చండి
SQLలో రెండు పట్టికలను పోల్చడానికి అత్యంత సాధారణ మార్గాలలో ఒకటి మినహాయించి ఆపరేటర్‌ని ఉపయోగించడం. ఇది మొదటి పట్టికలో ఉన్న వరుసలను కనుగొంటుంది కానీ రెండవ పట్టికలో లేదు.
ఈ క్రింది విధంగా నమూనా పట్టికలతో పోలికను నిర్వహించడానికి మేము దీన్ని ఉపయోగించవచ్చు:
ఎంచుకోండి *నమూనా_tb1 నుండి
మినహా
ఎంచుకోండి *
నమూనా_tb2 నుండి;
ఈ ఉదాహరణలో, EXCEPT ఆపరేటర్ రెండవ ప్రశ్న (sample_tb2)లో కనిపించని మొదటి ప్రశ్న (sample_tb1) నుండి అన్ని విభిన్న అడ్డు వరుసలను అందిస్తుంది.
యూనియన్ ఉపయోగించి రెండు పట్టికలను సరిపోల్చండి
GROUP BY నిబంధనతో కలిపి మనం ఉపయోగించగల రెండవ పద్ధతి UNION ఆపరేటర్. డూప్లికేట్ రికార్డులను భద్రపరుచుకుంటూ, ఒక టేబుల్‌లో ఉన్న రికార్డులను మరొకదానిలో కాకుండా గుర్తించడానికి ఇది సహాయపడుతుంది.
కింది వాటిలో ప్రదర్శించబడిన ప్రశ్నను తీసుకోండి:
ఎంచుకోండిఉద్యోగ గుర్తింపు,
మొదటి పేరు,
చివరి పేరు,
శాఖ,
జీతం
నుండి
(
ఎంచుకోండి
ఉద్యోగ గుర్తింపు,
మొదటి పేరు,
చివరి పేరు,
శాఖ,
జీతం
నుండి
నమూనా_tb1
యూనియన్ అన్ని
ఎంచుకోండి
ఉద్యోగ గుర్తింపు,
మొదటి పేరు,
చివరి పేరు,
శాఖ,
జీతం
నుండి
నమూనా_tb2
) AS మిళిత_డేటా
సమూహం ద్వారా
ఉద్యోగ గుర్తింపు,
మొదటి పేరు,
చివరి పేరు,
శాఖ,
జీతం
కలిగి
COUNT ( * ) = 1 ;
ఇచ్చిన ఉదాహరణలో, నకిలీలను ఉంచేటప్పుడు రెండు పట్టికల నుండి డేటాను కలపడానికి మేము UNION ALL ఆపరేటర్‌ని ఉపయోగిస్తాము.
మేము అన్ని నిలువు వరుసల ద్వారా కలిపి డేటాను సమూహపరచడానికి GROUP BY నిబంధనను ఉపయోగిస్తాము. చివరగా, ఒక గణనతో (నకిలీలు లేవు) ఉన్న రికార్డులు మాత్రమే ఎంచుకోబడ్డాయని నిర్ధారించుకోవడానికి మేము HAVING నిబంధనను ఉపయోగిస్తాము.
అవుట్‌పుట్:
ఈ పద్ధతి కొంచెం క్లిష్టంగా ఉంటుంది కానీ మీరు రెండు పట్టికల నుండి తప్పిపోయిన వాస్తవ డేటాను పొందడం వలన ఇది మరింత మెరుగైన అంతర్దృష్టిని అందిస్తుంది.
INNER JOINని ఉపయోగించి రెండు పట్టికలను సరిపోల్చండి
మీరు ఆలోచిస్తూ ఉంటే, ఇన్నర్ జాయిన్‌ని ఎందుకు ఉపయోగించకూడదు? మీరు పాయింట్ మీద ఉంటారు. మేము పట్టికలను సరిపోల్చడానికి మరియు సాధారణ రికార్డులను కనుగొనడానికి INNER JOINని ఉపయోగించవచ్చు.
ఉదాహరణకు కింది ప్రశ్నను తీసుకోండి:
ఎంచుకోండినమూనా_tb1. *
నుండి
నమూనా_tb1
లోపలి చేరడం నమూనా_tb2 ఆన్
నమూనా_tb1.employee_id = నమూనా_tb2.employee_id;
ఈ ఉదాహరణలో, మేము ఇచ్చిన నిలువు వరుస ఆధారంగా రెండు పట్టికలలో ఉన్న రికార్డులను కనుగొనడానికి SQL INNER JOINని ఉపయోగిస్తాము. ఇది పని చేస్తున్నప్పటికీ, డేటా వాస్తవానికి తప్పిపోయిందా లేదా రెండు టేబుల్‌లలో లేదా ఒకదానిలో ఉందా అని మీకు ఖచ్చితంగా తెలియనందున ఇది కొన్నిసార్లు తప్పుదారి పట్టించవచ్చు.
ముగింపు
ఈ ట్యుటోరియల్‌లో, SQLలో రెండు టేబుల్‌లను పోల్చడానికి మనం ఉపయోగించే అన్ని పద్ధతులు మరియు పద్ధతుల గురించి తెలుసుకున్నాము.