JOIN ప్రకటన

JOIN ఆపరేటర్ కనిపించడానికి అవసరమైన అవసరాలు

పట్టికలలో డేటా మొత్తం పెరిగేకొద్దీ, వాటిలో నకిలీ విలువలు తరచుగా కనిపిస్తాయి. ఉదాహరణకు, ఉత్పత్తి పట్టికలో బ్రాండ్ పేర్లు ఉన్నాయి. ఇది కొన్నిసార్లు పునరావృతమవుతుంది. వారి కోసం ప్రత్యేక బ్రాండ్ పట్టికను కలిగి ఉండటం ఉపయోగకరంగా ఉంటుంది, ఉదాహరణకు, అటువంటి డేటాను కలిగి ఉంటుంది:

• ఐడి - బ్రాండ్ ఐడి;
• పేరు - బ్రాండ్ పేరు;
• కంపెనీ_యజమాని - బ్రాండ్ యొక్క కంపెనీ యజమాని పేరు;
• company_contacts - బ్రాండ్ యజమాని యొక్క కంపెనీ పరిచయాలు.

అప్పుడు మేము అన్ని చిరునామాలను ఉంచగల చిరునామాల పట్టికను సృష్టించాలనుకుంటున్నాము:

• id - id-చిరునామాలు;
• దేశం;
• ప్రాంతం;
• నగరం;
• వీధి;
• ఇల్లు;
• జిప్.

అంతేకాకుండా, ఈ పట్టికలో బ్రాండ్-యాజమాన్య సంస్థల చిరునామాలను మాత్రమే కాకుండా, కస్టమర్లు మరియు ఉద్యోగుల చిరునామాలను కూడా నిల్వ చేయడం సాధ్యమవుతుంది. మరియు ఈ విధానం కేవలం డేటా మొత్తం (టేబుల్స్‌లోని వరుసల సంఖ్య) పెరుగుదల యొక్క పరిణామం. ఇది పట్టికలలో డేటాను మార్చడం మరియు వాటి సమగ్రతను నిర్వహించడం సులభం చేస్తుంది.

మీకు 5 మంది ఉద్యోగులు ఉన్నప్పుడు, మీరు వారి వృత్తిని వృత్తి కాలమ్‌లో నమోదు చేయవచ్చు . మీ కంపెనీలో మీకు 5 వేల మంది ఉద్యోగులు ఉంటే, మీకు x వృత్తుల జాబితా మరియు వారి బాధ్యతలతో కూడిన పట్టిక అవసరం.

జావా భాషలో, మార్గం ద్వారా, ఇలాంటిదే ఉంది. మీరు ఒక పద్ధతిలో చాలా కోడ్‌ని కలిగి ఉంటే, దానిని అనేక పద్ధతులుగా విభజించాలనే కోరిక ఉంది. ఒక తరగతిలో అనేక పద్ధతులు ఉంటే, నేను దానిని అనేక తరగతులుగా విభజించాలనుకుంటున్నాను.

అందుకే పెద్ద డేటాబేస్‌లు వేల సంఖ్యలో పట్టికలను కలిగి ఉంటాయి. మరియు దాదాపు అన్ని ప్రశ్నలు ఒకేసారి అనేక పట్టికలలో అమలు చేయబడతాయి. మరియు వెయ్యి రికార్డులను కలిగి ఉన్న మూడు పట్టికల వరుసల కార్టేసియన్ ఉత్పత్తి ఇప్పటికే ఒక బిలియన్ వరుసలు.

కానీ WHEREని ఉపయోగించి బిలియన్ అడ్డు వరుసలను ఫిల్టర్ చేయడానికి గంటలు పట్టవచ్చు. అందువల్ల, SQL భాష యొక్క సృష్టికర్తలు వారి పరిష్కారాన్ని అందించారు - JOIN ఆపరేటర్.

JOIN ఆపరేటర్‌కి పరిచయం

JOIN ఆపరేటర్ అనేది SQL సర్వర్‌కి స్పష్టంగా చెప్పడానికి ఉపయోగించబడుతుంది, మాకు అన్ని టేబుల్‌ల వరుసల కార్టేసియన్ ఉత్పత్తి అవసరం లేదు, కానీ IDని (లేదా మరొక విధంగా) ఉపయోగించి ఒకదానికొకటి సూచించే విభిన్న పట్టికల వరుసల స్మార్ట్ గ్లైయింగ్. . JOIN ఆపరేటర్‌ని ఉపయోగించి పట్టిక చేరికలను ప్రాసెస్ చేయడానికి సర్వర్‌కు ప్రత్యేక అల్గోరిథం ఉంది, ఇది అటువంటి కార్యకలాపాలను చాలా వేగంగా నిర్వహించడానికి అనుమతిస్తుంది. JOIN ఆపరేటర్ యొక్క సాధారణ రూపం క్రింది విధంగా ఉంది:

table 1 JOIN table 2 ON condition

మీరు టేబుల్1 మరియు టేబుల్2 పట్టికలను ఒక టేబుల్‌గా కలపాలని మరియు షరతును చేరడానికి ప్రమాణంగా ఉపయోగించాలని ఇది ఇక్కడ చెబుతోంది .

మన పాత ఉదాహరణను తీసుకుందాం:

SELECT * FROM employee, task WHERE emploee.id = task.emploee_id

మరియు దానిని JOIN ఆపరేటర్ ఉపయోగించి తిరిగి వ్రాయండి:

SELECT * FROM employee JOIN task ON emploee.id = task.emploee_id

రెండు ప్రశ్నలు మా విషయంలో ఒకే ఫలితాన్ని ఇస్తాయి, అయితే ఇది ప్రశ్నలు చాలా సరళంగా ఉన్నందున మాత్రమే. భవిష్యత్తులో, WHERE ఖచ్చితంగా అడ్డు వరుస ఫిల్టర్‌ను రూపొందించడానికి మిమ్మల్ని అనుమతిస్తుంది మరియు ON తర్వాత పేర్కొన్నది పట్టికలను లింక్ చేయడానికి సంక్లిష్ట స్క్రిప్ట్‌లను వ్రాయడానికి మిమ్మల్ని అనుమతిస్తుంది. మీరు JOIN స్టేట్‌మెంట్‌ను ఉపయోగిస్తున్నప్పుడు మారుపేర్లను (టేబుల్ మారుపేర్లు) కూడా ఉపయోగించవచ్చు. ఉదాహరణ:

SELECT * FROM employee e JOIN task t ON e.id = t.emploee_id