ఆధారిత పట్టిక
ఇప్పుడు మన ప్రశ్నలను కొంచెం క్లిష్టతరం చేద్దాం. మా ఉద్యోగుల కోసం టాస్క్‌లతో మా డేటాబేస్‌కు కొత్త టాస్క్ టేబుల్‌ని యాడ్ చేద్దాం. మరి ఇందులో ఎలాంటి ఎంట్రీలు ఉన్నాయో చూద్దాం:
SELECT * FROM taskఅటువంటి అభ్యర్థన యొక్క ఫలితం:
| id | ఉద్యోగి_ఐడి | పేరు | గడువు |
|---|---|---|---|
| 1 | 1 | ఫ్రంటెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-01 |
| 2 | 2 | బ్యాకెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-15 |
| 3 | 5 | కాఫీ కొనండి | 2022-07-01 |
| 4 | 5 | కాఫీ కొనండి | 2022-08-01 |
| 5 | 5 | కాఫీ కొంటాను | 2022-09-01 |
| 6 | (శూన్య) | కార్యాలయాన్ని శుభ్రం చేయండి | (శూన్య) |
| 7 | 4 | జీవితం ఆనందించండి | (శూన్య) |
| 8 | 6 | జీవితం ఆనందించండి | (శూన్య) |
ఈ పట్టికలో 4 నిలువు వరుసలు మాత్రమే ఉన్నాయి:
- id — ప్రత్యేకమైన పని సంఖ్య (మరియు పట్టికలోని వరుసలు);
- Employee_id — ఉద్యోగి పట్టిక నుండి పనిని కేటాయించిన ఉద్యోగి యొక్క ID;
- పేరు - పని యొక్క పేరు మరియు వివరణ;
- గడువు - పనిని పూర్తి చేయవలసిన సమయం.
కొన్ని సూక్ష్మ నైపుణ్యాలకు శ్రద్ధ వహించండి. టాస్క్ N6లో ఉద్యోగి_ఐడి లేదు, మా వద్ద క్లీనర్ లేదు. పని ఉంది, కానీ ప్రదర్శకుడు లేదు. అది జరుగుతుంది.
అలాగే, 6-9 పనులకు నిర్ణీత గడువు లేదు. ఒక పనిని క్రమం తప్పకుండా మరియు నిరంతరంగా చేసినప్పుడు ఇది జరుగుతుంది. ఉదాహరణకు, ఆఫీసుని ప్రతిరోజూ శుభ్రం చేయాలి, కానీ మీరు ప్రతిరోజూ జీవితాన్ని ఆస్వాదించాలి :)
ఒక టేబుల్ మరొక టేబుల్ నుండి IDలను ఉపయోగిస్తే, అటువంటి పట్టికను డిపెండెంట్ అంటారు .
బహుళ పట్టికలకు వ్యతిరేకంగా ప్రశ్న
ఇక్కడ టాస్క్ టేబుల్‌లో “జీవితాన్ని ఆస్వాదించడం” అనే రెండు టాస్క్‌లు ఉన్నాయని మనం చూస్తాము. ఈ అదృష్టవంతులు ఎవరో మనకు ఎలా తెలుస్తుంది?
దీన్ని చేయడానికి, SQLలో, మీరు ఒకేసారి రెండు పట్టికలలో ప్రశ్నను అమలు చేయవచ్చు. సాధారణంగా, SQLలో, మీరు ఒకే సమయంలో ఎన్ని టేబుల్‌లనైనా ప్రశ్నించవచ్చు. అటువంటి అభ్యర్థన యొక్క సాధారణ ఆకృతి:
SELECT columns
FROM Table 1, table 2, tableN
ముఖ్యమైనది! మీరు ఒకే సమయంలో అనేక పట్టికలకు ఒక ప్రశ్నను వ్రాస్తే, ఫలితంగా మీరు పట్టిక వరుసల యొక్క కార్టేసియన్ ఉత్పత్తి అని పిలవబడే దాన్ని పొందుతారు. మొదటి పట్టిక నుండి ప్రతి అడ్డు వరుస రెండవ పట్టిక నుండి ప్రతి అడ్డు వరుసకు అతుక్కొని ఉంటుంది.
అంటే, మీకు మొదటి పట్టికలో 5 వరుసలు మరియు రెండవదానిలో 10 వరుసలు ఉంటే, మీకు మొత్తం 50 వరుసలు ఉంటాయి. జావాలో, ఈ ప్రశ్న ఇలా కనిపిస్తుంది:
for (String row1 : table1)
{
for (String row2 : table2)
{
System.out.println(row1 + row2);
}
}మన ప్రశ్నను ఒకేసారి రెండు పట్టికలకు వ్రాసి ఏమి జరుగుతుందో చూద్దాం:
SELECT * FROM employee, taskమరియు ఈ ప్రశ్న యొక్క ఫలితం:
| id | పేరు | వృత్తి | జీతం | వయస్సు | id | ఉద్యోగి | _id | పేరు | గడువు |
|---|---|---|---|---|---|---|---|---|---|
| 1 | ఇవనోవ్ ఇవాన్ | ప్రోగ్రామర్ | 100000 | 25 | 1 | 1 | ఫ్రంటెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-01 | |
| 2 | పెట్రోవ్ పీటర్ | ప్రోగ్రామర్ | 80000 | 23 | 1 | 1 | ఫ్రంటెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-01 | |
| 3 | ఇవనోవ్ సెర్గీ | టెస్టర్ | 40000 | ముప్పై | 1 | 1 | ఫ్రంటెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-01 | |
| 4 | రాబినోవిచ్ మోయిషా | దర్శకుడు | 200000 | 35 | 1 | 1 | ఫ్రంటెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-01 | |
| 5 | కిరియెంకో అనస్తాసియా | ఆఫీసు మేనేజర్ | 40000 | 25 | 1 | 1 | ఫ్రంటెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-01 | |
| 6 | వాస్కా | పిల్లి | 1000 | 3 | 1 | 1 | ఫ్రంటెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-01 | |
| 1 | ఇవనోవ్ ఇవాన్ | ప్రోగ్రామర్ | 100000 | 25 | 2 | 2 | బ్యాకెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-15 | |
| 2 | పెట్రోవ్ పీటర్ | ప్రోగ్రామర్ | 80000 | 23 | 2 | 2 | బ్యాకెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-15 | |
| 3 | ఇవనోవ్ సెర్గీ | టెస్టర్ | 40000 | ముప్పై | 2 | 2 | బ్యాకెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-15 | |
| 4 | రాబినోవిచ్ మోయిషా | దర్శకుడు | 200000 | 35 | 2 | 2 | బ్యాకెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-15 | |
| 5 | కిరియెంకో అనస్తాసియా | ఆఫీసు మేనేజర్ | 40000 | 25 | 2 | 2 | బ్యాకెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-15 |
మాకు మొత్తం 48 ఫలితాల పంక్తులు ఉన్నాయి, కానీ ఇక్కడ నేను 11 మాత్రమే ఇచ్చాను. లేకపోతే, తగినంత స్థలం ఉండదు.
మూడు విషయాలపై శ్రద్ధ వహించండి:
- అదే పేర్లతో నిలువు వరుసలు: id . ఇది ఉద్యోగి టేబుల్ నుండి ఐడి మరియు టాస్క్ టేబుల్ నుండి ఐడి .
- ప్రతి పట్టిక యొక్క వరుసలు పునరావృతమవుతాయి. ఎడమ కాలమ్‌లో, ID 6 తర్వాత ID = 1 మళ్లీ వస్తుంది.
- మేము అర్ధంలేని వరుసలను కలిగి ఉన్నాము, ఉదాహరణకు, id (ఉద్యోగి పట్టిక నుండి) 6 మరియు అదే వరుసలో ఉద్యోగి_id 1.
అర్థం లేని పంక్తులను తొలగించడం
మా ఫలిత పట్టికలో చాలా వరుసలు ఉన్నాయి , ఇది రెండు టేబుల్‌ల ఉద్యోగి మరియు టాస్క్‌లోని అన్ని వరుసల కార్టెసియన్ ఉత్పత్తి .
తార్కికంగా, ఉద్యోగి_id అడ్డు వరుస 3 అయితే, అది id 3 ఉన్న ఉద్యోగి పట్టికలోని అడ్డు వరుసకు మాత్రమే కట్టుబడి ఉండాలి. WHEREతో ఈ అపార్థాన్ని పరిష్కరించడానికి ప్రయత్నిద్దాం.
ఇలా ఒక ప్రశ్న రాద్దాం:
SELECT * FROM employee, task
WHERE emploee.id = task.emploee_id
మరియు ఈ ప్రశ్న యొక్క ఫలితం:
| id | పేరు | వృత్తి | జీతం | వయస్సు | id | ఉద్యోగి_ఐడి | పేరు | గడువు |
|---|---|---|---|---|---|---|---|---|
| 1 | ఇవనోవ్ ఇవాన్ | ప్రోగ్రామర్ | 100000 | 25 | 1 | 1 | ఫ్రంటెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-01 |
| 2 | పెట్రోవ్ పీటర్ | ప్రోగ్రామర్ | 80000 | 23 | 2 | 2 | బ్యాకెండ్‌లో బగ్‌ను పరిష్కరించండి | 2022-06-15 |
| 4 | రాబినోవిచ్ మోయిషా | దర్శకుడు | 200000 | 35 | 7 | 4 | జీవితం ఆనందించండి | (శూన్య) |
| 5 | కిరియెంకో అనస్తాసియా | ఆఫీసు మేనేజర్ | 40000 | 25 | 3 | 5 | కాఫీ కొనండి | 2022-07-01 |
| 5 | కిరియెంకో అనస్తాసియా | ఆఫీసు మేనేజర్ | 40000 | 25 | 4 | 5 | కాఫీ కొనండి | 2022-08-01 |
| 5 | కిరియెంకో అనస్తాసియా | ఆఫీసు మేనేజర్ | 40000 | 25 | 5 | 5 | కాఫీ కొంటాను | 2022-09-01 |
| 6 | వాస్కా | పిల్లి | 1000 | 3 | 8 | 6 | జీవితం ఆనందించండి | (శూన్య) |
శుభవార్త ఏమిటంటే అర్థరహిత పంక్తులు అదృశ్యమయ్యాయి: మొదటి నిలువు వరుసలోని id ఎల్లప్పుడూ ఉద్యోగి_idకి సమానంగా ఉంటుంది.
చేదువార్త ఏమిటంటే, ఎవరికీ అప్పగించని పనులు, కార్యాలయాన్ని శుభ్రం చేయడం వంటివి పోయాయి. వారి ఉద్యోగి_ఐడి NULL, కాబట్టి వారు ఎక్కడ పూర్తి చేసిన తర్వాత విస్మరించబడ్డారు.
GO TO FULL VERSION