పైథాన్ మరియు ఆబ్జెక్ట్-రిలేషనల్ మ్యాప్స్ గురించి మీరు తెలుసుకోవలసిన ప్రతిదీ

మీరు ఆబ్జెక్ట్-రిలేషనల్ మ్యాపింగ్ (ORM) గురించి విని ఉండవచ్చు. మీరు ఒకదాన్ని కూడా ఉపయోగించుకోవచ్చు, కానీ అవి ఖచ్చితంగా ఏమిటి? మరియు మీరు వాటిని పైథాన్‌లో ఎలా ఉపయోగిస్తారు?

ORM లు మరియు పైథాన్ గురించి మీరు తెలుసుకోవలసిన ప్రతిదీ ఇక్కడ ఉంది.

---

---

ORM అంటే ఏమిటి?

ఆబ్జెక్ట్-రిలేషనల్ మ్యాపింగ్ (ORM) అనేది డేటాబేస్‌ను యాక్సెస్ చేయడానికి ఉపయోగించే ప్రోగ్రామింగ్ టెక్నిక్. ఇది మీ డేటాబేస్‌ను వరుస వస్తువులుగా బహిర్గతం చేస్తుంది. డేటాను చొప్పించడానికి లేదా తిరిగి పొందడానికి మీరు SQL ఆదేశాలను వ్రాయవలసిన అవసరం లేదు, మీరు ఆబ్జెక్ట్‌లకు జతచేయబడిన లక్షణాల శ్రేణి మరియు పద్ధతులను ఉపయోగిస్తారు.

ఇది సంక్లిష్టంగా మరియు అనవసరంగా అనిపించవచ్చు, కానీ అవి మీకు చాలా సమయాన్ని ఆదా చేస్తాయి మరియు మీ డేటాబేస్ యాక్సెస్‌ను నియంత్రించడంలో సహాయపడతాయి.

ఇక్కడ ఒక ఉదాహరణ. వెబ్‌సైట్ పాస్‌వర్డ్ సెక్యూరిటీలో వివరించిన విధంగా మీరు మీ డేటాబేస్‌లోకి పాస్‌వర్డ్‌ని చొప్పించినప్పుడల్లా దాన్ని హ్యాష్ చేయాలనుకుంటున్నారని చెప్పండి. సాధారణ వినియోగ కేసులకు ఇది సమస్య కాదు --- మీరు చొప్పించే ముందు గణన చేయండి. కానీ మీరు కోడ్‌లోని అనేక ప్రదేశాలలో రికార్డును చొప్పించాల్సి వస్తే? మరొక ప్రోగ్రామర్ మీ టేబుల్‌లోకి చొప్పించినట్లయితే, మరియు దాని గురించి మీకు తెలియదా?

ORM ని ఉపయోగించడం ద్వారా, మీ డేటాబేస్‌లోని ఏదైనా అడ్డు వరుస లేదా ఫీల్డ్ యాక్సెస్ చేయబడినప్పుడు, మీ ఇతర, కస్టమ్ కోడ్ మొదట అమలు చేయబడిందని నిర్ధారించుకోవడానికి మీరు కోడ్ రాయవచ్చు.

ఇది 'సత్యానికి ఏకైక మూలం' గా కూడా పనిచేస్తుంది. మీరు అనుకూల గణనను మార్చాలనుకుంటే, మీరు దానిని ఒకే చోట మాత్రమే మార్చాలి, అనేక కాదు. దీనితో అనేక సూత్రాలను అమలు చేయడం సాధ్యమవుతుంది పైథాన్‌లో ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్ (OOP) , కానీ ORM లు డేటాబేస్ యాక్సెస్‌ను నియంత్రించడానికి OOP సూత్రాలతో కలిసి పనిచేస్తాయి.

---

---

ఓఆర్‌ఎమ్‌ని ఉపయోగించినప్పుడు కొన్ని విషయాలు గమనించాలి, మరియు మీరు ఒకదాన్ని ఉపయోగించకూడదనుకునే పరిస్థితులు ఉన్నాయి, కానీ అవి సాధారణంగా ఒక మంచి కోడ్‌బేస్‌లో ఉండడం మంచిది.

SQLAlchemy ఉపయోగించి పైథాన్‌లో ORM లు

పైథాన్‌లోని అనేక పనుల వలె, మీ స్వంతంగా వ్రాయడం కంటే మాడ్యూల్‌ను దిగుమతి చేసుకోవడం వేగంగా మరియు సులభంగా ఉంటుంది. వాస్తవానికి, మీ స్వంత ORM వ్రాయడం సాధ్యమే, కానీ చక్రాన్ని ఎందుకు తిరిగి ఆవిష్కరించాలి?

---

---

కింది ఉదాహరణలు అన్నింటినీ ఉపయోగిస్తాయి SQLAlchemy , ఒక ప్రముఖ పైథాన్ ORM, కానీ అమలుతో సంబంధం లేకుండా అనేక సూత్రాలు వర్తిస్తాయి.

SQLAlchemy కోసం పైథాన్‌ను ఏర్పాటు చేస్తోంది

సరిగ్గా దూకడానికి ముందు, మీరు SQLAlchemy తో పైథాన్ అభివృద్ధి కోసం మీ యంత్రాన్ని సెటప్ చేయాలి.

ఈ ఉదాహరణలతో పాటు అనుసరించడానికి మీరు పైథాన్ 3.6 ని ఉపయోగించాలి. పాత వెర్షన్‌లు పనిచేస్తున్నప్పటికీ, దిగువ కోడ్ అమలు చేయడానికి ముందు కొంత సవరణ అవసరం. తేడాలపై ఖచ్చితంగా తెలియదా? మా పైథాన్ FAQ అన్ని తేడాలను కవర్ చేస్తుంది.

కోడింగ్ చేయడానికి ముందు, మీరు పైథాన్ పర్యావరణాన్ని ఏర్పాటు చేయాలి, ఇది ఇతర దిగుమతి చేసుకున్న పైథాన్ ప్యాకేజీలతో సమస్యలను నివారిస్తుంది.

మీరు కలిగి ఉన్నారని నిర్ధారించుకోండి PIP, పైథాన్ ప్యాకేజీ మేనేజర్ ఇన్‌స్టాల్ చేయబడింది, ఇది పైథాన్ యొక్క అత్యంత ఆధునిక వెర్షన్‌లతో వస్తుంది.

మీరు వెళ్లడానికి సిద్ధంగా ఉన్న తర్వాత, మీరు SQLAlchemy ని సిద్ధం చేయడం ద్వారా ప్రారంభించవచ్చు. కమాండ్ లైన్‌లో మీ పైథాన్ ఎన్విరాన్మెంట్ లోపల నుండి, SQLAlchemy ని ఇన్‌స్టాల్ చేయండి పైప్ సంస్థాపన ఆదేశం:

pip install SQLAlchemy-1.2.9

ది 1.2.9 వెర్షన్ నంబర్. తాజా ప్యాకేజీని పొందడానికి మీరు దీన్ని వదిలివేయవచ్చు, కానీ నిర్దిష్టంగా ఉండటం మంచి పద్ధతి. కొత్త విడుదల ఎప్పుడు మీ ప్రస్తుత కోడ్‌ని విచ్ఛిన్నం చేస్తుందో మీకు తెలియదు.

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

SQLAlchemy లో నమూనాలు

ORM యొక్క ముఖ్య భాగాలలో ఒకటి a మోడల్ . ఇది పైథాన్ క్లాస్, ఇది టేబుల్ ఎలా ఉండాలో మరియు అది ఎలా పని చేయాలో తెలియజేస్తుంది. ఇది ORM వెర్షన్ పట్టికను సృష్టించండి SQL లో ప్రకటన. మీ డేటాబేస్‌లోని ప్రతి పట్టికకు మీకు ఒక మోడల్ అవసరం.

మీకు ఇష్టమైన టెక్స్ట్ ఎడిటర్ లేదా IDE ని తెరిచి, అనే కొత్త ఫైల్‌ను సృష్టించండి test.py . ఈ స్టార్టర్ కోడ్‌ని నమోదు చేయండి, ఫైల్‌ను సేవ్ చేసి, దాన్ని అమలు చేయండి:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
engine = create_engine('sqlite://') # Create the database in memory
Base.metadata.create_all(engine) # Create all the tables in the database


ఈ కోడ్ అనేక పనులు చేస్తుంది. దిగుమతులు అవసరం కాబట్టి పైథాన్‌కు అవసరమైన SQLAlchemy మాడ్యూల్స్ ఎక్కడ దొరుకుతాయో అర్థం చేసుకోవచ్చు. మీ నమూనాలు దీనిని ఉపయోగిస్తాయి డిక్లేరేటివ్_బేస్ తరువాత, మరియు అది ఊహించిన విధంగా పని చేయడానికి ఏదైనా కొత్త మోడళ్లను కాన్ఫిగర్ చేస్తుంది.

ది సృష్టించు_ఇంజైన్ పద్ధతి మీ డేటాబేస్‌కు కొత్త కనెక్షన్‌ను సృష్టిస్తుంది. మీకు ఇప్పటికే డేటాబేస్ ఉంటే, మీరు మార్చాల్సి ఉంటుంది స్క్లైట్: // మీ డేటాబేస్ URI కి. అలాగే, ఈ కోడ్ మెమరీలో మాత్రమే కొత్త డేటాబేస్‌ను సృష్టిస్తుంది. మీ కోడ్ అమలు పూర్తయిన తర్వాత డేటాబేస్ నాశనం అవుతుంది.

చివరగా, ది create_all పద్ధతి మీ డేటాబేస్‌లో మీ మోడ్‌లలో నిర్వచించిన అన్ని పట్టికలను సృష్టిస్తుంది. మీరు ఇంకా ఏ మోడళ్లను నిర్వచించనందున, ఏమీ జరగదు. మీకు ఎలాంటి సమస్యలు లేదా అక్షర దోషాలు లేవని నిర్ధారించుకోవడానికి ముందుకు వెళ్లి ఈ కోడ్‌ని అమలు చేయండి.

ఒక మోడల్ తయారు చేద్దాం. మీ ఫైల్ ఎగువన మరొక దిగుమతిని జోడించండి:

from sqlalchemy import Column, Integer, String

ఇది దిగుమతి చేస్తుంది కాలమ్ , పూర్ణ సంఖ్య , మరియు స్ట్రింగ్ SQLAlchemy నుండి గుణకాలు. డేటాబేస్ పట్టికలు, ఫీల్డ్‌లు, నిలువు వరుసలు మరియు డేటాటైప్‌లు ఎలా పనిచేస్తాయో వారు నిర్వచిస్తారు.

కింద డిక్లేరేటివ్_బేస్ , మీ మోడల్ క్లాస్‌ని సృష్టించండి:

class Cars(Base):
__tablename__ = 'cars'
id = Column(Integer, primary_key=True)
make = Column(String(50), nullable=False)
color = Column(String(50), nullable=False)

ఈ సాధారణ ఉదాహరణ కార్లను ఉపయోగిస్తుంది, కానీ మీ పట్టికలలో ఏదైనా డేటా ఉండవచ్చు.

ప్రతి తరగతి వారసత్వంగా పొందాలి ఆధారం . మీ డేటాబేస్ టేబుల్ పేరు దీనిలో నిర్వచించబడింది పట్టిక పేరు__ . ఇది తరగతి పేరు వలె ఉండాలి, కానీ ఇది కేవలం సిఫార్సు మాత్రమే, మరియు అవి సరిపోలకపోతే ఏమీ విరిగిపోదు.

చివరగా, ప్రతి కాలమ్ క్లాస్‌లోని పైథాన్ వేరియబుల్‌గా నిర్వచించబడింది. వివిధ డేటా రకాలు ఉపయోగించబడతాయి మరియు ప్రాథమిక_కై లక్షణం సృష్టించడానికి SQLAlchemy కి చెబుతుంది id కాలమ్ ప్రాథమిక కీగా.

ముందుకు సాగండి మరియు చివరిసారి దిగుమతిని జోడించండి, ఈ సారి విదేశీ కీ మాడ్యూల్. దీన్ని మీతో పాటు జోడించండి కాలమ్ దిగుమతి:

from sqlalchemy import Column, ForeignKey, Integer, String

ఇప్పుడు రెండవ మోడల్ క్లాస్‌ని సృష్టించండి. ఈ తరగతి అంటారు కారు యజమానులు , మరియు నిల్వ చేసిన నిర్దిష్ట కార్ల యజమాని వివరాలను స్టోర్ చేస్తుంది కా ర్లు పట్టిక:

class CarOwners(Base):
__tablename__ = 'carowners'
id = Column(Integer, primary_key=True)
name = Column(String(50), nullable=False)
age = Column(Integer, nullable=False)
car_id = Column(Integer, ForeignKey('cars.id'))
car = relationship(Cars)

ఇక్కడ అనేక కొత్త లక్షణాలు ప్రవేశపెట్టబడ్డాయి. ది కారు_ఐడి ఫీల్డ్ ఒక విదేశీ కీగా నిర్వచించబడింది. ఇది దీనికి లింక్ చేయబడింది id లో కా ర్లు పట్టిక. లోయర్ కేస్ టేబుల్ పేరు ఎలా ఉపయోగించబడుతుందో గమనించండి.

చివరగా, ఒక లక్షణం కారు a గా నిర్వచించబడింది సంబంధం . ఇది మీ మోడల్‌ని యాక్సెస్ చేయడానికి అనుమతిస్తుంది కా ర్లు ఈ వేరియబుల్ ద్వారా పట్టిక. ఇది క్రింద ప్రదర్శించబడింది.

మీరు ఇప్పుడు ఈ కోడ్‌ని అమలు చేస్తే, ఏమీ జరగదని మీరు చూస్తారు. ఇది గమనించదగినది ఏదైనా చేయమని మీరు చెప్పకపోవడమే దీనికి కారణం.

SQLAlchemy లో వస్తువులు

ఇప్పుడు మీ నమూనాలు సృష్టించబడ్డాయి, మీరు వస్తువులను యాక్సెస్ చేయడం ప్రారంభించవచ్చు మరియు డేటాను చదవడం మరియు వ్రాయడం ప్రారంభించవచ్చు. మీ లాజిక్‌ను దాని స్వంత క్లాస్ మరియు ఫైల్‌లో ఉంచడం మంచిది, కానీ ప్రస్తుతానికి, ఇది మోడల్స్‌తో పాటు ఉండగలదు.

డేటా వ్రాయడం

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

మీకు రాయడం అలవాటు కావచ్చు ఇన్సర్ట్ SQL లో ప్రకటనలు. SQLAlchemy మీ కోసం దీనిని నిర్వహిస్తుంది. ఇక్కడ ఒక వరుసను ఎలా ఇన్సర్ట్ చేయాలో ఇక్కడ ఉంది కా ర్లు మోడల్ కోసం కొత్త దిగుమతితో ప్రారంభించండి సెషన్ మేకర్ :

from sqlalchemy.orm import sessionmaker

సృష్టించడానికి ఇది అవసరం సెషన్ మరియు DBS సెషన్ డేటాను చదవడానికి మరియు వ్రాయడానికి ఉపయోగించే వస్తువులు:

DBSession = sessionmaker(bind=engine)
session = DBSession()

ఇప్పుడు దీన్ని మీ కింద ఉంచండి create_all ప్రకటన:

car1 = Cars(
make='Ford',
color='silver'
)
session.add(car1)
session.commit()

ఆ కోడ్‌ను విచ్ఛిన్నం చేద్దాం. వేరియబుల్ కారు 1 ఆధారంగా ఒక వస్తువుగా నిర్వచించబడింది కా ర్లు మోడల్ దీని తయారీ మరియు రంగు పారామితులుగా సెట్ చేయబడ్డాయి. ఇది 'నన్ను కారుని తయారు చేయండి, కానీ ఇంకా డేటాబేస్‌కు వ్రాయవద్దు' అని చెప్పడం లాంటిది. ఈ కారు మెమరీలో ఉంది కానీ రాయడానికి వేచి ఉంది.

సెషన్‌కు కారును జోడించండి సెషన్. జోడించండి , ఆపై దానిని డేటాబేస్‌తో వ్రాయండి సెషన్.కామిట్ .

ఇప్పుడు యజమానిని చేర్చుదాం:

owner1 = CarOwners(
name='Joe',
age='99',
car_id=(car1.id)
)
session.add(owner1)
session.commit()

ఈ కోడ్ మునుపటి చొప్పించడానికి దాదాపు సమానంగా ఉంటుంది కా ర్లు మోడల్ ఇక్కడ ప్రధాన వ్యత్యాసం ఏమిటంటే కారు_ఐడి ఒక విదేశీ కీ కాబట్టి ఇతర పట్టికలో ఉన్న అడ్డు వరుస ఐడి అవసరం. దీని ద్వారా యాక్సెస్ చేయబడుతుంది car1.id ఆస్తి.

SQLAlchemy మీ కోసం దీనిని నిర్వహిస్తున్నందున మీరు డేటాబేస్‌ని ప్రశ్నించాల్సిన అవసరం లేదు లేదా ఏవైనా ఐడీలను తిరిగి ఇవ్వాల్సిన అవసరం లేదు (మీరు ముందుగా డేటాను కమిట్ చేసినంత వరకు).

డేటాను చదవడం

మీరు కొంత డేటాను వ్రాసిన తర్వాత, మీరు దాన్ని తిరిగి చదవడం ప్రారంభించవచ్చు. ప్రశ్నించడం ఎలాగో ఇక్కడ ఉంది కా ర్లు మరియు కారు యజమానులు పట్టికలు:

result = session.query(Cars).all()

ఇది చాలా సులభం. ఉపయోగించడం ద్వారా ప్రశ్న లో కనుగొనబడిన పద్ధతి సెషన్ , మీరు మోడల్ పేర్కొనండి, ఆపై ఉపయోగించండి అన్ని అన్ని ఫలితాలను తిరిగి పొందడానికి పద్ధతి. ఒక ఫలితం మాత్రమే ఉంటుందని మీకు తెలిస్తే, మీరు దాన్ని ఉపయోగించవచ్చు ప్రధమ పద్ధతి:

result = session.query(Cars).first()

మీరు మోడల్‌ని ప్రశ్నించి, మీ రిటర్న్ ఫలితాలను వేరియబుల్‌లో స్టోర్ చేసిన తర్వాత, మీరు ఆబ్జెక్ట్ ద్వారా డేటాను యాక్సెస్ చేయవచ్చు:

print(result[0].color)

ఇది 'సిల్వర్' రంగును ప్రింట్ చేస్తుంది, ఎందుకంటే ఆ రికార్డు మొదటి వరుస. మీకు కావాలంటే మీరు ఫలిత వస్తువుపై లూప్ చేయవచ్చు.

మీరు మీ మోడల్‌లోని సంబంధాన్ని నిర్వచించినట్లుగా, చేరడాన్ని పేర్కొనకుండా సంబంధిత పట్టికలలో డేటాను యాక్సెస్ చేయడం సాధ్యమవుతుంది:

result = session.query(CarOwners).all()
print(result[0].name)
print(result[0].car.color)

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

ORM ల గురించి ఏది ఇష్టపడదు?

ఈ ట్యుటోరియల్ చాలా ప్రాథమికాలను మాత్రమే కవర్ చేసింది, కానీ ఒకసారి మీరు వాటిని పట్టుకున్న తర్వాత, మీరు అధునాతన అంశాలపై కదలవచ్చు. ORM లకు కొన్ని సంభావ్య ప్రతికూలతలు ఉన్నాయి:

• ఏవైనా ప్రశ్నలు అమలు కావడానికి ముందు మీరు మీ మోడల్‌ని వ్రాయాలి.
• ఇది నేర్చుకోవడానికి మరొక కొత్త వాక్యనిర్మాణం.
• సాధారణ అవసరాల కోసం ఇది చాలా క్లిష్టంగా ఉండవచ్చు.
• ప్రారంభించడానికి మీరు తప్పనిసరిగా మంచి డేటాబేస్ డిజైన్‌ను కలిగి ఉండాలి.

ఈ సమస్యలు తమంతట తాముగా పెద్ద సమస్య కాదు, కానీ అవి గమనించాల్సిన విషయాలు. మీరు ఇప్పటికే ఉన్న డేటాబేస్‌తో పని చేస్తుంటే, మీరు చిక్కుకోవచ్చు.

ORM మీకు సరైన సాధనం అని మీకు నమ్మకం లేకపోతే, మీరు దీని గురించి చదివారని నిర్ధారించుకోండి ముఖ్యమైన SQL ఆదేశాలు ప్రోగ్రామర్లు తెలుసుకోవాలి .

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ మీరు వెంటనే విండోస్ 11 కి అప్‌గ్రేడ్ చేయాలా?

విండోస్ 11 త్వరలో వస్తుంది, కానీ మీరు వీలైనంత త్వరగా అప్‌డేట్ చేయాలా లేక కొన్ని వారాలు వేచి ఉండాలా? తెలుసుకుందాం.

తదుపరి చదవండి సంబంధిత అంశాలు

• ప్రోగ్రామింగ్
• పైథాన్
• SQL
• కోడింగ్ ట్యుటోరియల్స్

రచయిత గురుంచి జో కోబర్న్(136 కథనాలు ప్రచురించబడ్డాయి)

జో UK లోని లింకన్ విశ్వవిద్యాలయం నుండి కంప్యూటర్ సైన్స్‌లో గ్రాడ్యుయేట్. అతను ఒక ప్రొఫెషనల్ సాఫ్ట్‌వేర్ డెవలపర్, మరియు అతను డ్రోన్‌లను ఎగురవేయనప్పుడు లేదా సంగీతం వ్రాయనప్పుడు, అతను తరచుగా ఫోటోలు తీయడం లేదా వీడియోలను ఉత్పత్తి చేయడం చూడవచ్చు.

ట్విట్టర్‌లో పదాలను మ్యూట్ చేయడం ఎలా

జో కోబర్న్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి