# Working with Data: Relational Databases

|![ Sketchnote by [(@sketchthedocs)](https://sketchthedocs.dev) ](../../sketchnotes/05-RelationalData.png)|
|:---:|
| Working With Data: Relational Databases - _Sketchnote by [@nitya](https://twitter.com/nitya)_ |

మీరు గతంలో సమాచారాన్ని నిల్వ చేయడానికి స్ప్రెడ్షీట్ ఉపయోగించిన అవకాశం ఉంది. మీకు వరుసలు మరియు కాలమ్స్ సెట్ ఉండేవి, అక్కడ వరుసలు సమాచారాన్ని (లేదా డేటాను) కలిగి ఉండేవి, మరియు కాలమ్స్ ఆ సమాచారాన్ని వివరించేవి (కొన్నిసార్లు మెటాడేటా అని పిలవబడుతుంది). ఒక రిలేషనల్ డేటాబేస్ ఈ కాలమ్స్ మరియు వరుసల ప్రాథమిక సూత్రంపై నిర్మించబడింది, ఇది మీకు సమాచారాన్ని అనేక పట్టికలలో విస్తరించడానికి అనుమతిస్తుంది. ఇది మీరు మరింత సంక్లిష్టమైన డేటాతో పని చేయడానికి, ప్రతిరూపణను నివారించడానికి, మరియు డేటాను అన్వేషించడంలో సౌలభ్యాన్ని కలిగిస్తుంది. relational database యొక్క సూత్రాలను పరిశీలిద్దాం.

## [Pre-lecture quiz](https://ff-quizzes.netlify.app/en/ds/quiz/8)

## It all starts with tables

ఒక relational database యొక్క ప్రాథమికంగా పట్టికలు ఉంటాయి. స్ప్రెడ్షీట్ లాగా, ఒక పట్టిక కాలమ్స్ మరియు వరుసల సమాహారం. వరుసలో మనం పని చేయదలచిన డేటా లేదా సమాచారం ఉంటుంది, ఉదాహరణకు ఒక నగర పేరు లేదా వర్షపాతం పరిమాణం. కాలమ్స్ వారు నిల్వ చేసే డేటాను వివరించును.

నగరాల గురించి సమాచారాన్ని నిల్వ చేయడానికి ఒక పట్టిక ప్రారంభిద్దాం. మనం వారి పేరు మరియు దేశం తో ప్రారంభించవచ్చు. మీరు దీన్ని క్రింది విధంగా పట్టికలో నిల్వ చేయవచ్చు:

| City     | Country       |
| -------- | ------------- |
| Tokyo    | Japan         |
| Atlanta  | United States |
| Auckland | New Zealand   |

**city**, **country** మరియు **population** అనే కాలమ్ పేర్లు నిల్వ చేస్తున్న డేటాను వివరించాయి, మరియు ప్రతి వరుస ఒక నగరానికి సంబంధించిన సమాచారాన్ని కలిగి ఉంది.

## The shortcomings of a single table approach

పైన ఉన్న పట్టిక మీకు సాపేక్షంగా పరిచితంగా అనిపించవచ్చు. మనం మన పెరుగుతున్న డేటాబేస్‌కు కొన్ని అదనపు డేటాను జోడిద్దాం - వార్షిక వర్షపాతం (మిల్లీమీటర్లలో). మనం 2018, 2019 మరియు 2020 సంవత్సరాలపై దృష్టి సారిద్దాం. టోక్యోకు జోడిస్తే, ఇది ఇలా ఉండవచ్చు:

| City  | Country | Year | Amount |
| ----- | ------- | ---- | ------ |
| Tokyo | Japan   | 2020 | 1690   |
| Tokyo | Japan   | 2019 | 1874   |
| Tokyo | Japan   | 2018 | 1445   |

మన పట్టిక గురించి మీరు ఏమి గమనిస్తారు? మీరు నగర పేరు మరియు దేశం పునరావృతం అవుతున్నట్లు గమనించవచ్చు. ఇది చాలా నిల్వను తీసుకోవచ్చు, మరియు అనవసరం గా అనేక కాపీలు ఉండటం అవసరం లేదు. చివరికి, టోక్యోకు మనం ఆసక్తి ఉన్న ఒకే పేరు ఉంది.

సరే, మరొకటి ప్రయత్నిద్దాం. ప్రతి సంవత్సరానికి కొత్త కాలమ్స్ జోడిద్దాం:

| City     | Country       | 2018 | 2019 | 2020 |
| -------- | ------------- | ---- | ---- | ---- |
| Tokyo    | Japan         | 1445 | 1874 | 1690 |
| Atlanta  | United States | 1779 | 1111 | 1683 |
| Auckland | New Zealand   | 1386 | 942  | 1176 |

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

కాబట్టి మనకు అనేక పట్టికలు మరియు సంబంధాలు అవసరం. మన డేటాను విడగొట్టి, పునరావృతాన్ని నివారించి, డేటాతో పని చేయడంలో మరింత సౌలభ్యం కలిగి ఉండవచ్చు.

## The concepts of relationships

మన డేటాకు తిరిగి వెళ్ళి, మనం దానిని ఎలా విభజించాలో నిర్ణయిద్దాం. మనం నగరాల పేరు మరియు దేశాన్ని నిల్వ చేయాలనుకుంటున్నాము, కాబట్టి ఇది ఒక పట్టికలో ఉత్తమంగా పనిచేస్తుంది.

| City     | Country       |
| -------- | ------------- |
| Tokyo    | Japan         |
| Atlanta  | United States |
| Auckland | New Zealand   |

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

> ✅ Primary key is frequently abbreviated as PK

### cities

| city_id | City     | Country       |
| ------- | -------- | ------------- |
| 1       | Tokyo    | Japan         |
| 2       | Atlanta  | United States |
| 3       | Auckland | New Zealand   |

> ✅ మీరు ఈ పాఠంలో "id" మరియు "primary key" పదాలను మార్పిడి గా ఉపయోగిస్తున్నాము. ఇక్కడ ఉన్న సూత్రాలు DataFrames కు వర్తిస్తాయి, మీరు తరువాత అన్వేషిస్తారు. DataFrames "primary key" పదజాలం ఉపయోగించవు, కానీ అవి చాలా సమానంగా ప్రవర్తిస్తాయి.

మన cities పట్టిక సృష్టించిన తర్వాత, వర్షపాతం నిల్వ చేద్దాం. నగరంపై పూర్తి సమాచారాన్ని పునరావృతం చేయడం కాకుండా, మనం id ఉపయోగించవచ్చు. కొత్తగా సృష్టించిన పట్టికలో కూడా *id* కాలమ్ ఉండాలి, ఎందుకంటే అన్ని పట్టికలకు id లేదా ప్రాథమిక కీ ఉండాలి.

### rainfall

| rainfall_id | city_id | Year | Amount |
| ----------- | ------- | ---- | ------ |
| 1           | 1       | 2018 | 1445   |
| 2           | 1       | 2019 | 1874   |
| 3           | 1       | 2020 | 1690   |
| 4           | 2       | 2018 | 1779   |
| 5           | 2       | 2019 | 1111   |
| 6           | 2       | 2020 | 1683   |
| 7           | 3       | 2018 | 1386   |
| 8           | 3       | 2019 | 942    |
| 9           | 3       | 2020 | 1176   |

కొత్తగా సృష్టించిన **rainfall** పట్టికలో ఉన్న **city_id** కాలమ్ గమనించండి. ఈ కాలమ్ విలువలు **cities** పట్టికలోని IDs ను సూచిస్తాయి. సాంకేతిక relational data పదజాలంలో, దీనిని **foreign key** అంటారు; ఇది మరొక పట్టిక నుండి ప్రాథమిక కీ. మీరు దీన్ని ఒక సూచన లేదా పాయింటర్ గా భావించవచ్చు. **city_id** 1 టోక్యోను సూచిస్తుంది.

> [!NOTE] 
> Foreign key is frequently abbreviated as FK

## Retrieving the data

మన డేటాను రెండు పట్టికలుగా విడగొట్టిన తర్వాత, దాన్ని ఎలా పొందాలో మీరు ఆశ్చర్యపోతున్నారా? మనం MySQL, SQL Server లేదా Oracle వంటి relational database ఉపయోగిస్తే, మనం Structured Query Language లేదా SQL అనే భాషను ఉపయోగించవచ్చు. SQL (కొన్నిసార్లు sequel అని ఉచ్చరించబడుతుంది) relational database లో డేటాను పొందడానికి మరియు మార్చడానికి ఉపయోగించే ప్రామాణిక భాష.

డేటాను పొందడానికి మీరు `SELECT` ఆజ్ఞను ఉపయోగిస్తారు. ప్రాథమికంగా, మీరు చూడదలచిన కాలమ్స్ ను **select** చేస్తారు మరియు అవి ఉన్న పట్టిక నుండి **from** చేస్తారు. మీరు నగరాల పేర్లను మాత్రమే ప్రదర్శించాలనుకుంటే, మీరు క్రింది విధంగా ఉపయోగించవచ్చు:

```sql
SELECT city
FROM cities;

-- Output:
-- Tokyo
-- Atlanta
-- Auckland
```

`SELECT` అనేది మీరు కాలమ్స్ జాబితా చేసే చోట, మరియు `FROM` అనేది మీరు పట్టికలను జాబితా చేసే చోట.

> [!NOTE] 
> SQL సింటాక్స్ కేస్-ఇన్సెన్సిటివ్, అంటే `select` మరియు `SELECT` ఒకే అర్థం. అయితే, మీరు ఉపయోగిస్తున్న డేటాబేస్ రకం ఆధారంగా కాలమ్స్ మరియు పట్టికలు కేస్ సెన్సిటివ్ కావచ్చు. అందువల్ల, ప్రోగ్రామింగ్ లో ప్రతిదీ కేస్ సెన్సిటివ్ గా పరిగణించడం ఉత్తమ ఆచారం. SQL ప్రశ్నలు రాయేటప్పుడు సాధారణంగా కీవర్డ్స్ ను పెద్ద అక్షరాల్లో వ్రాయడం సాంప్రదాయం.

పై ప్రశ్న అన్ని నగరాలను ప్రదర్శిస్తుంది. మనం కేవలం న్యూజీలాండ్ లోని నగరాలను ప్రదర్శించాలనుకుంటే, మనకు ఒక ఫిల్టర్ అవసరం. దీనికి SQL కీవర్డ్ `WHERE`, లేదా "ఎక్కడ ఏదైనా నిజం" ఉపయోగిస్తారు.

```sql
SELECT city
FROM cities
WHERE country = 'New Zealand';

-- Output:
-- Auckland
```

## Joining data

ఇప్పటి వరకు మనం ఒకే పట్టిక నుండి డేటాను పొందాము. ఇప్పుడు మనం **cities** మరియు **rainfall** నుండి డేటాను కలపాలనుకుంటున్నాము. ఇది *joining* ద్వారా చేయబడుతుంది. మీరు రెండు పట్టికల మధ్య ఒక సీమ్ సృష్టించి, ప్రతి పట్టికలోని ఒక కాలమ్ విలువలను సరిపోల్చుతారు.

మన ఉదాహరణలో, మనం **rainfall** లోని **city_id** కాలమ్ ను **cities** లోని **city_id** కాలమ్ తో సరిపోల్చుతాము. ఇది వర్షపాతం విలువను దాని సంబంధిత నగరంతో సరిపోల్చుతుంది. మనం చేసే జాయిన్ రకం *inner* జాయిన్ అని పిలవబడుతుంది, అంటే ఎలాంటి వరుసలు ఇతర పట్టికలో ఏదైనా సరిపోలకపోతే అవి ప్రదర్శించబడవు. మన సందర్భంలో ప్రతి నగరానికి వర్షపాతం ఉంది, కాబట్టి అన్ని ప్రదర్శించబడతాయి.

2019 సంవత్సరానికి మన నగరాల వర్షపాతం పొందుదాం.

మనం దీన్ని దశలవారీగా చేస్తాము. మొదటి దశ డేటాను కలపడం, సీమ్ కోసం కాలమ్స్ సూచించడం - **city_id** మునుపటి విధంగా.

```sql
SELECT cities.city
    rainfall.amount
FROM cities
    INNER JOIN rainfall ON cities.city_id = rainfall.city_id
```

మనం కావలసిన రెండు కాలమ్స్ మరియు పట్టికలను **city_id** ద్వారా కలపాలని హైలైట్ చేశాము. ఇప్పుడు మనం `WHERE` స్టేట్‌మెంట్ జోడించి కేవలం 2019 సంవత్సరాన్ని ఫిల్టర్ చేయవచ్చు.

```sql
SELECT cities.city
    rainfall.amount
FROM cities
    INNER JOIN rainfall ON cities.city_id = rainfall.city_id
WHERE rainfall.year = 2019

-- Output

-- city     | amount
-- -------- | ------
-- Tokyo    | 1874
-- Atlanta  | 1111
-- Auckland |  942
```

## Summary

Relational databases అనేవి సమాచారాన్ని అనేక పట్టికల మధ్య విభజించి, ప్రదర్శన మరియు విశ్లేషణ కోసం తిరిగి కలిపే విధానంపై ఆధారపడి ఉంటాయి. ఇది లెక్కింపులు చేయడానికి మరియు డేటాను మానిప్యులేట్ చేయడానికి అధిక స్థాయి సౌలభ్యాన్ని అందిస్తుంది. మీరు relational database యొక్క ప్రాథమిక సూత్రాలను మరియు రెండు పట్టికల మధ్య జాయిన్ ఎలా చేయాలో చూశారు.

## 🚀 Challenge

ఇంటర్నెట్ లో అనేక relational databases అందుబాటులో ఉన్నాయి. మీరు పై నేర్చుకున్న నైపుణ్యాలను ఉపయోగించి డేటాను అన్వేషించవచ్చు.

## Post-Lecture Quiz

## [Post-lecture quiz](https://ff-quizzes.netlify.app/en/ds/quiz/9)

## Review & Self Study

SQL మరియు relational database సూత్రాలపై మీ అన్వేషణ కొనసాగించడానికి [Microsoft Learn](https://docs.microsoft.com/learn?WT.mc_id=academic-77958-bethanycheum) లో అనేక వనరులు అందుబాటులో ఉన్నాయి

- [Describe concepts of relational data](https://docs.microsoft.com//learn/modules/describe-concepts-of-relational-data?WT.mc_id=academic-77958-bethanycheum)
- [Get Started Querying with Transact-SQL](https://docs.microsoft.com//learn/paths/get-started-querying-with-transact-sql?WT.mc_id=academic-77958-bethanycheum) (Transact-SQL అనేది SQL యొక్క ఒక వెర్షన్)
- [SQL content on Microsoft Learn](https://docs.microsoft.com/learn/browse/?products=azure-sql-database%2Csql-server&expanded=azure&WT.mc_id=academic-77958-bethanycheum)

## Assignment

[Displaying airport data](assignment.md)

---

<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:  
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకం వల్ల కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారుల బాధ్యత మేము తీసుకోము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->