பைதான் மற்றும் பொருள்-தொடர்புடைய வரைபடங்களைப் பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டிய அனைத்தும்

பைதான் மற்றும் பொருள்-தொடர்புடைய வரைபடங்களைப் பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டிய அனைத்தும்

பொருள்-தொடர்புடைய மேப்பிங் (ORM) பற்றி நீங்கள் கேள்விப்பட்டிருக்கலாம். நீங்கள் ஒன்றை கூட பயன்படுத்தியிருக்கலாம், ஆனால் அவை உண்மையில் என்ன? பைத்தானில் அவற்றை எவ்வாறு பயன்படுத்துவது?





ORM கள் மற்றும் பைதான் பற்றி நீங்கள் தெரிந்து கொள்ள வேண்டிய அனைத்தும் இங்கே.



ORM என்றால் என்ன?

ஆப்ஜெக்ட்-ரிலேஷனல் மேப்பிங் (ORM) என்பது ஒரு தரவுத்தளத்தை அணுக பயன்படும் ஒரு நிரலாக்க நுட்பமாகும். இது உங்கள் தரவுத்தளத்தை தொடர்ச்சியான பொருள்களாக வெளிப்படுத்துகிறது. தரவைச் செருக அல்லது மீட்டெடுக்க நீங்கள் SQL கட்டளைகளை எழுத வேண்டியதில்லை, பொருள்களுடன் இணைக்கப்பட்ட தொடர்ச்சியான பண்புகளையும் முறைகளையும் பயன்படுத்துகிறீர்கள்.





இது சிக்கலானதாகவும் தேவையற்றதாகவும் தோன்றலாம், ஆனால் அவை உங்களுக்கு நிறைய நேரத்தை மிச்சப்படுத்தும், மேலும் உங்கள் தரவுத்தளத்திற்கான அணுகலைக் கட்டுப்படுத்த உதவும்.

இங்கே ஒரு உதாரணம். வலைத்தள கடவுச்சொல் பாதுகாப்பில் விளக்கப்பட்டுள்ளபடி, உங்கள் தரவுத்தளத்தில் கடவுச்சொல்லை செருகும்போதெல்லாம் நீங்கள் அதை ஹாஷ் செய்ய விரும்புகிறீர்கள் என்று சொல்லுங்கள். எளிமையான பயன்பாட்டு நிகழ்வுகளுக்கு இது ஒரு பிரச்சனை அல்ல --- நீங்கள் செருகுவதற்கு முன் கணக்கீடு செய்யுங்கள். ஆனால் குறியீட்டில் பல இடங்களில் பதிவைச் செருக வேண்டுமானால் என்ன செய்வது? மற்றொரு புரோகிராமர் உங்கள் அட்டவணையில் செருகினால் என்ன செய்வது?



ORM ஐப் பயன்படுத்துவதன் மூலம், உங்கள் தரவுத்தளத்தில் எந்த வரிசை அல்லது புலத்தையும் அணுகும் போது, ​​உங்கள் மற்ற, தனிப்பயன் குறியீடு முதலில் செயல்படுத்தப்படுவதை உறுதிசெய்ய குறியீட்டை எழுதலாம்.

இது 'உண்மையின் ஒற்றை ஆதாரமாக' செயல்படுகிறது. நீங்கள் தனிப்பயன் கணக்கீட்டை மாற்ற விரும்பினால், நீங்கள் அதை ஒரே இடத்தில் மாற்ற வேண்டும், பல அல்ல. இந்த கொள்கைகளில் பலவற்றைச் செய்ய முடியும் பைத்தானில் பொருள் சார்ந்த நிரலாக்கம் (OOP) , ஆனால் ORM கள் ஒரு தரவுத்தளத்திற்கான அணுகலைக் கட்டுப்படுத்த OOP கொள்கைகளுடன் இணைந்து செயல்படுகின்றன.



ஒரு ORM ஐப் பயன்படுத்தும் போது கவனிக்க வேண்டிய சில விஷயங்கள் உள்ளன, மேலும் நீங்கள் ஒன்றைப் பயன்படுத்த விரும்பாத சூழ்நிலைகள் உள்ளன, ஆனால் அவை பொதுவாக ஒரு நல்ல குறியீடாக, குறிப்பாக ஒரு பெரிய குறியீடாக இருக்க வேண்டும்.

SQLAlchemy பயன்படுத்தி பைத்தானில் ORM கள்

பைத்தானில் உள்ள பல பணிகளைப் போலவே, உங்களுடையதை எழுதுவதை விட ஒரு தொகுதியை இறக்குமதி செய்வது விரைவானது மற்றும் எளிதானது. நிச்சயமாக, உங்கள் சொந்த ORM ஐ எழுத முடியும், ஆனால் ஏன் சக்கரத்தை மீண்டும் கண்டுபிடிப்பது?



பின்வரும் எடுத்துக்காட்டுகள் அனைத்தும் பயன்படுத்தப்படுகின்றன SQLAlchemy , ஒரு பிரபலமான பைதான் ORM, ஆனால் பல கொள்கைகள் செயல்படுத்தப்படுவதைப் பொருட்படுத்தாமல் பொருந்தும்.

SQLAlchemy க்கு பைத்தானை அமைத்தல்

குதிப்பதற்கு முன், SQLAlchemy உடன் பைதான் வளர்ச்சிக்கு உங்கள் இயந்திரத்தை அமைக்க வேண்டும்.

இந்த எடுத்துக்காட்டுகளுடன் நீங்கள் பைதான் 3.6 ஐப் பயன்படுத்த வேண்டும். பழைய பதிப்புகள் வேலை செய்யும் போது, ​​கீழே உள்ள குறியீடு இயங்குவதற்கு முன் சில மாற்றங்கள் தேவைப்படும். வேறுபாடுகள் குறித்து உறுதியாக தெரியவில்லையா? எங்கள் பைதான் கேள்விகள் அனைத்து வேறுபாடுகளையும் உள்ளடக்கியது.

குறியிடுவதற்கு முன், நீங்கள் ஒரு பைதான் சூழலை அமைக்க வேண்டும், இது இறக்குமதி செய்யப்பட்ட பிற பைதான் தொகுப்புகளுடன் சிக்கல்களைத் தடுக்கும்.

உங்களிடம் இருப்பதை உறுதிப்படுத்திக் கொள்ளுங்கள் பிஐபி, பைதான் தொகுப்பு மேலாளர் நிறுவப்பட்டது, இது பைத்தானின் பெரும்பாலான நவீன பதிப்புகளுடன் வருகிறது.

நீங்கள் செல்லத் தயாரானவுடன், நீங்கள் 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 க்கு. அது போல், இந்த குறியீடு நினைவகத்தில் மட்டுமே ஒரு புதிய தரவுத்தளத்தை உருவாக்கும். உங்கள் குறியீடு இயங்குவதை முடித்தவுடன் தரவுத்தளம் அழிக்கப்படும்.

இறுதியாக, தி அனைத்தையும் உருவாக்கவும் முறை உங்கள் தரவுத்தளத்தில் உங்கள் முறைகளில் வரையறுக்கப்பட்ட அனைத்து அட்டவணைகளையும் உருவாக்குகிறது. நீங்கள் இன்னும் எந்த மாதிரிகளையும் வரையறுக்காததால், எதுவும் நடக்காது. மேலே சென்று இந்த குறியீட்டை இயக்கவும்.

ஒரு மாதிரியை உருவாக்குவோம். உங்கள் கோப்பின் மேல் மற்றொரு இறக்குமதியைச் சேர்க்கவும்:

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 ஐ உருவாக்க சொல்கிறது ஐடி நெடுவரிசை முதன்மை விசையாக.

மேலே சென்று ஒரு கடைசி இறக்குமதியைச் சேர்க்கவும், இந்த முறை வெளிநாட்டு கீ தொகுதி உங்களுடன் இதைச் சேர்க்கவும் நெடுவரிசை இறக்குமதி:

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)

பல புதிய பண்புக்கூறுகள் இங்கு அறிமுகப்படுத்தப்பட்டுள்ளன. தி கார்_ஐடி புலம் ஒரு வெளிநாட்டு விசையாக வரையறுக்கப்படுகிறது. இது இணைக்கப்பட்டுள்ளது ஐடி இல் கார்கள் மேசை. சிறிய எழுத்து அட்டவணை பெயர் எவ்வாறு பயன்படுத்தப்படுகிறது என்பதைக் கவனியுங்கள், பெரிய வகுப்பு வகுப்பு பெயரால் குறிப்பிடப்பட்டுள்ளது.

இறுதியாக, ஒரு பண்பு கார் என வரையறுக்கப்படுகிறது உறவு . இது உங்கள் மாதிரியை அணுக அனுமதிக்கிறது கார்கள் இந்த மாறி மூலம் அட்டவணை. இது கீழே நிரூபிக்கப்பட்டுள்ளது.

நீங்கள் இப்போது இந்த குறியீட்டை இயக்கினால், எதுவும் நடக்காது என்பதை நீங்கள் காண்பீர்கள். ஏனென்றால், கவனிக்கத்தக்க எதையும் செய்ய நீங்கள் இதுவரை சொல்லவில்லை.

SQLAlchemy இல் உள்ள பொருள்கள்

இப்போது உங்கள் மாதிரிகள் உருவாக்கப்பட்டுள்ளன, நீங்கள் பொருட்களை அணுக ஆரம்பிக்கலாம் மற்றும் தரவைப் படிக்கவும் எழுதவும் முடியும். உங்கள் தர்க்கத்தை அதன் சொந்த வகுப்பு மற்றும் கோப்பில் வைப்பது நல்லது, ஆனால் இப்போதைக்கு, அது மாடல்களுடன் இருக்க முடியும்.

தரவு எழுதுதல்

இந்த எடுத்துக்காட்டில், நீங்கள் அதைப் படிப்பதற்கு முன் சில தரவுகளை தரவுத்தளத்தில் செருக வேண்டும். நீங்கள் ஏற்கனவே உள்ள தரவுத்தளத்தைப் பயன்படுத்துகிறீர்கள் என்றால், உங்களிடம் ஏற்கனவே தரவு இருக்கலாம். எந்த வழியிலும், தரவை எவ்வாறு செருகுவது என்பதை அறிவது இன்னும் மிகவும் பயனுள்ளதாக இருக்கும்.

நீங்கள் எழுதப் பழகியிருக்கலாம் செருகவும் SQL இல் அறிக்கைகள். SQLAlchemy இதை உங்களுக்காக கையாளுகிறது. ஒரு வரிசையை எப்படி செருகுவது என்பது இங்கே கார்கள் மாதிரி. புதிய இறக்குமதியுடன் தொடங்கவும் அமர்வு தயாரிப்பாளர் :

from sqlalchemy.orm import sessionmaker

இதை உருவாக்க இது தேவை அமர்வு மற்றும் DBSession பொருள்கள், தரவைப் படிக்கவும் எழுதவும் பயன்படுகிறது:

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

இப்போது இதை உங்கள் அடியில் வைக்கவும் அனைத்தையும் உருவாக்கவும் அறிக்கை:

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 கட்டுரைகள் வெளியிடப்பட்டன)

ஜோ இங்கிலாந்தின் லிங்கன் பல்கலைக்கழகத்தில் கணினி அறிவியலில் பட்டதாரி. அவர் ஒரு தொழில்முறை மென்பொருள் டெவலப்பர், அவர் ட்ரோன்கள் பறக்காதபோது அல்லது இசை எழுதாதபோது, ​​அவர் அடிக்கடி புகைப்படம் எடுப்பதை அல்லது வீடியோக்களை தயாரிப்பதை காணலாம்.

ஜிமெயிலை பெயரால் வரிசைப்படுத்துவது எப்படி
ஜோ கோபர்னிடமிருந்து மேலும்

எங்கள் செய்திமடலுக்கு குழுசேரவும்

தொழில்நுட்ப குறிப்புகள், மதிப்புரைகள், இலவச மின் புத்தகங்கள் மற்றும் பிரத்யேக ஒப்பந்தங்களுக்கு எங்கள் செய்திமடலில் சேரவும்!

குழுசேர இங்கே சொடுக்கவும்