SQLAlchemy में दुबका हुआ एक क्राउचिंग टाइगर। मूल बातें

शुभ दिन

आज मैं ORM SQLAlchemy के बारे में बात करना चाहता हूं। आइए बात करते हैं कि यह अपनी क्षमताओं और लचीलेपन के बारे में क्या है, और उन मामलों पर भी विचार करें जो हमेशा स्पष्ट रूप से वर्णित नहीं हैं।

इस ओआरएम में औसत से ऊपर प्रवेश की सीमा है, इसलिए मैं एक सरल भाषा में और उदाहरणों के साथ सब कुछ समझाने की कोशिश करूंगा। यह लेख उन लोगों के लिए उपयोगी होगा, जो पहले से ही स्क्वलकेम के साथ काम करते हैं और अपने कौशल को अपग्रेड करना चाहते हैं या बस इस लाइब्रेरी से परिचित हो सकते हैं।

उपयोग की गई प्रोग्रामिंग भाषा पायथन 3.6 है।
DB - PostgreSQL।
जीथब लिंक

तो ORM क्या है?

ORM (ऑब्जेक्ट-रिलेशनल मैपिंग) एक ऐसी तकनीक है जो आपको उन मॉडलों को मैप करने की अनुमति देती है जिनके प्रकार असंगत हैं। उदाहरण के लिए: एक डेटाबेस तालिका और एक प्रोग्रामिंग भाषा ऑब्जेक्ट।

दूसरे शब्दों में, आप डेटाबेस टेबल में डेटा को प्रबंधित करने के लिए क्लास ऑब्जेक्ट तक पहुंच सकते हैं। आप डेटाबेस तालिकाओं के लिए मैप की गई, सबसे महत्वपूर्ण बात, इनहेरिट क्लास ऑब्जेक्ट्स बना सकते हैं, संशोधित कर सकते हैं, हटा सकते हैं, जो कोड बेस की सामग्री को काफी कम कर देता है।

SQLAlchemy का उपयोग करने के लिए, आपको यह समझने की आवश्यकता है कि यह कैसे काम करता है।

जो डेवलपर्स Django-ORM का उपयोग करते हैं, उन्हें ORM क्वेरी बनाने के लिए अपनी मानसिकता को थोड़ा पुनर्निर्माण करना होगा। मेरी राय में, SQLAlchemy एक कार्यात्मक राक्षस है जिसकी क्षमताओं का आप उपयोग कर सकते हैं और उपयोग करना चाहिए, लेकिन आपको यह समझने की आवश्यकता है कि ORM हमेशा सही नहीं होते हैं। इसलिए, हम उन क्षणों पर चर्चा करेंगे जब इस तकनीक का उपयोग उचित होगा।

SQLAlchemy में घोषणात्मक और गैर-घोषणात्मक मॉडल परिभाषाओं की अवधारणा है।

गैर-घोषणात्मक परिभाषा में मैपर () का उपयोग होता है, जो प्रत्येक डेटाबेस कॉलम और मॉडल वर्ग के मानचित्रण का वर्णन करता है।

यह आलेख मॉडल की एक घोषणात्मक परिभाषा का उपयोग करता है।

यहाँ और

DB संरचना

पूर्ण डेटा संगति के लिए, आइए निम्नलिखित तालिकाएँ बनाएँ।

मूल मॉडल का उपयोग डेटाबेस में मूल स्तंभों को निर्धारित करने के लिए किया जाता है।

class BaseModel(Base): __abstract__ = True id = Column(Integer, nullable=False, unique=True, primary_key=True, autoincrement=True) created_at = Column(TIMESTAMP, nullable=False) updated_at = Column(TIMESTAMP, nullable=False) def __repr__(self): return "<{0.__class__.__name__}(id={0.id!r})>".format(self) 

कर्मचारी - कार्यालय में काम करने वाले कर्मचारी का वर्णन करने वाली एक तालिका

 class Employee(BaseModel): __tablename__ = 'employees' first_name = Column(VARCHAR(255), nullable=False) last_name = Column(VARCHAR(255), nullable=False) phone = Column(VARCHAR(255), unique=True, nullable=True) description = Column(VARCHAR(255), nullable=True) 

EmployeeWithSkills एक तालिका नहीं है। वर्ग कर्मचारी से विरासत में मिला। तर्क को अलग करने और कक्षा का उपयोग करने का एक शानदार अवसर जैसे कि यह एक अलग तालिका थी।

 class EmployeeWithSkills(Employee): skills = relation(Skill, secondary=EmployeesSkills.__tablename__, lazy='joined') 

विभाग - वह विभाग जिसमें यह कर्मचारी काम करता है। एक व्यक्ति में कई विभाग शामिल हो सकते हैं।

 class Department(BaseModel): __tablename__ = 'departments' name = Column(VARCHAR(255), nullable=False) description = Column(VARCHAR(255), nullable=False) 

कर्मचारी और इकाइयों का पत्राचार तालिका जिसमें वह एक सदस्य है।

 class EmployeeDepartments(BaseModel): __tablename__ = 'employee_departments' employee_id = Column(Integer, ForeignKey('employees.id', ondelete='CASCADE'), nullable=False, index=True) department_id = Column(Integer, ForeignKey('departments.id', ondelete='CASCADE'), nullable=False, index=True) 

कर्मचारियों और उनके कौशल की पत्राचार तालिका।

 class EmployeesSkills(BaseModel): __tablename__ = 'employees_skills' employee_id = Column(ForeignKey('employee.id', ondelete='CASCADE'), nullable=False, index=True) skill_id = Column(ForeignKey('skills.id', ondelete='CASCADE'), nullable=False, index=True) 

हम एलेम्बिक पैकेज का उपयोग करके माइग्रेशन बनाते हैं, जो आपको स्वचालित रूप से उत्पन्न करने की अनुमति देता है। इस पाठ में, ऑटो-जनरेशन ऑफ माइग्रेशन पूरी तरह से स्वीकार्य है।

नवीनतम माइग्रेशन में परीक्षण डेटा होता है जो डेटाबेस को भर देगा।
एलेम्बिक को कैसे कॉन्फ़िगर किया जा सकता है यहां पढ़ा जा सकता है
हम प्रवास को अंजाम देने के लिए क़ीमती औलीमिक अपग्रेड हेड का उपयोग करते हैं।

अनुरोध और संबंध

आइए पहले अनुरोध करें और कर्मचारी के बारे में उसकी आईडी से जानकारी प्राप्त करें।
अनुरोध इस तरह दिखेगा:

lesson1:

 employee = session.query(Employee).filter(Employee.id == eid).one() output: ID: 2, Tony Stark 

.one() अंत में इसका मतलब है कि हम केवल एक प्रविष्टि प्राप्त करने का इरादा रखते हैं। यदि कई प्रविष्टियाँ हैं, तो एक उपयुक्त अपवाद उठाया जाएगा।

यदि हम सभी उपलब्ध विभागों को प्राप्त करना चाहते हैं, तो हम .all() का उपयोग करके निम्नलिखित क्वेरी का उपयोग कर सकते हैं

lesson2:

 emmployee = session.query(Department).all() output: ID: 2, name: Guards ID: 4, name: Legions 

एकत्रीकरण कार्यों के साथ काम करने पर विचार करें।

हम अंतर्निहित फ़ंक्शन का उपयोग करके उपलब्ध विभागों की संख्या प्राप्त कर सकते हैं।
.count() या .count() उपयोग करें। दूसरी विधि का उपयोग करते हुए, आप किसी भी SQL फ़ंक्शन का उपयोग करके या तो select कर सकते हैं या मध्यवर्ती परिणामों की गणना कर सकते हैं।

lesson3:

 def get_departments_count(session: DBSession) -> int: count = session.query(Department).count() return count def get_departments_func_count(session: DBSession) -> int: count = session.query(func.count(Department.id)).scalar() return count 

कई डेवलपर्स अनुरोध में डेटा की जांच करने के लिए count() फ़ंक्शन का उपयोग करते हैं। यह एक अच्छा अभ्यास नहीं है, जिससे अतिरिक्त डेटाबेस संसाधनों का उपयोग होता है और क्वेरी निष्पादन समय बढ़ता है। एक अच्छा समाधान exists() फ़ंक्शन का उपयोग करने के लिए जो एक स्केलर मान लौटाता है:
lesson3:

 def check_department_exists(session: DBSession, department_name: str) -> bool: is_exists = session.query(exists().where(Department.name == department_name)).scalar() return is_exists 

आगे बढ़ते हुए, हम कार्य को जटिल करते हैं और इकाई relation या relationship परिचित होते हैं। तथ्य यह है कि SQLAlchemy विदेशी_की का उपयोग करने के अलावा
डेटाबेस स्तर पर, वस्तुओं के बीच संबंधों का भी उपयोग किया जाता है।

इस प्रकार, हम डेटाबेस पंक्ति को ऑब्जेक्ट में विदेशी कुंजी पर निर्भर कर सकते हैं।
ये ऑब्जेक्ट डेटाबेस तालिकाओं पर एक प्रक्षेपण हैं, परस्पर जुड़े हुए हैं।

SQLAlchemy में Relations का एक लचीला विन्यास है, जो आपको डेटाबेस से अलग-अलग तरीकों से अलग-अलग समय पर नामित तर्क lazy का उपयोग करके डेटा प्राप्त करने की अनुमति देता है।

"आलस्य" की मुख्य डिग्री:

• select डिफ़ॉल्ट है। ORM केवल डेटा एक्सेस करते समय एक अनुरोध करता है। यह एक अलग अनुरोध में किया जाता है।
• dynamic - आपको अनुरोध ऑब्जेक्ट प्राप्त करने की अनुमति देता है, जिसे वांछित के रूप में संशोधित किया जा सकता है। यह सभी () या एक () या किसी भी अन्य उपलब्ध तरीकों को कॉल करने के बाद ही डेटाबेस से डेटा प्राप्त करता है।
• joined - LEFT JOIN का उपयोग करके मुख्य अनुरोध में जोड़ा गया है। इसे तुरंत किया जाता है।
• subquery - चयन के समान, लेकिन उपश्रेणी के रूप में निष्पादित।

डिफ़ॉल्ट का select ।

प्रश्नों को छानना स्थिर और गतिशील हो सकता है। डायनामिक फ़िल्टरिंग फ़िल्टर के साथ अनुरोध को भरने की अनुमति देता है, जो फ़ंक्शन की प्रगति के आधार पर भिन्न हो सकता है।

lesson4:

 def dynamic_filter(session: DBSession, filter: DFilter = None): query = session.query(Employee) if filter is not None: query = query.filter(*filter.conds) employees = query.all() return employees 

DFilter फ़िल्टर वर्ग किसी भी इनपुट के आधार पर फ़िल्टर को परिभाषित करता है। यदि फ़िल्टर वर्ग परिभाषित किया गया है, लेकिन अनुरोध शर्तों में आगे लागू होता है।

.Filter () फ़ंक्शन SQLAlchemy बाइनरी शर्तों को स्वीकार करता है, इसलिए इसे * का उपयोग करके दिखाया जा सकता है

गतिशील फिल्टर का उपयोग केवल कल्पना द्वारा सीमित है। क्वेरी के परिणाम से पता चलता है कि वर्तमान में कौन से नायक निष्क्रिय हैं।

 output: Inactive_heros: Name: Tony Stark Name: Scott Lang Name: Peter Parker 

मैं कई-कई संबंधों के साथ काम करने का सुझाव देता हूं।

हमारे पास एक एम्प्लॉई टेबल है जिसमें एंप्लॉयीजस्किल्स पत्राचार टेबल से संबंध है। इसमें कर्मचारी टेबल पर विदेशी_की और विदेशी_की शामिल है
कौशल तालिका के लिए।

सबक 5:

 def get_employee_with_skills(session: DBSession, eid: int): employee = session.query(EmployeeWithSkills).filter(EmployeeWithSkills.id == eid).one() return employee output: Employee Tony Stark has skills: Skill: Fly, Desc: I belive I can Fly. I belive I can touch the sky Skill: Light Shield, Desc: Light protect. Perfect for everything 

उपरोक्त क्वेरी में EmployeeWithSkills वर्ग का उपयोग करते हुए, हम इसे एक डेटाबेस तालिका के रूप में संदर्भित करते हैं, लेकिन वास्तव में ऐसी कोई तालिका मौजूद नहीं है। यह वर्ग एक संबंध रखने वाले कर्मचारी से अलग है, जिसके कई-कई संबंध हैं। इसलिए हम कक्षाओं के तर्क को अलग कर सकते हैं, इसे संबंधों के एक अलग सेट के साथ भर सकते हैं। अनुरोध के परिणामस्वरूप, हम कर्मचारियों में से एक के कौशल को देखेंगे।

चूंकि कर्मचारी कई विभागों में हो सकता है, इसलिए एक संबंध बनाएं जो आपको यह जानकारी प्राप्त करने की अनुमति देता है।

EmployeeWithDepartments वर्ग को कर्मचारी से विरासत में मिला और निम्नलिखित जोड़ें:

 class EmployeeWithDepartments(Employee): departments = relation( Department, # primaryjoin=EmployeeDepartments.employee_id == Employee.id, secondary=EmployeeDepartments.__tablename__, # secondaryjoin=EmployeeDepartments.department_id == Department.id, ) 

बनाया वर्ग एक नया डेटाबेस तालिका नहीं है। यह अभी भी एक ही कर्मचारी तालिका है, केवल relation का उपयोग करके विस्तारित किया गया है। इस तरह आप प्रश्नों में Employee या EmployeeWithDepartments सारणी तालिका का उपयोग कर सकते हैं। अंतर केवल relation की अनुपस्थिति / उपस्थिति में होगा।

पहला तर्क बताता है कि हम किस तालिका से relation बनाएंगे।
primaryjoin वह स्थिति है जिसके द्वारा ऑब्जेक्ट से जुड़ी होने से पहले दूसरी तालिका को जोड़ा जाएगा।
secondary मिलान के लिए विदेशी_की युक्त तालिका का नाम है। कई-से-कई के मामले में उपयोग किया जाता है।
secondaryjoin - अंतिम के साथ मध्यवर्ती तालिका के मिलान के लिए स्थितियां।

primaryjoin और primaryjoin जटिल परिस्थितियों में पत्राचार को स्पष्ट रूप से इंगित करने के लिए कार्य करते हैं।

कभी-कभी ऐसी परिस्थितियाँ उत्पन्न होती हैं जब ऐसे फिल्टर्स बनाना आवश्यक होता है जिनके क्षेत्र संबंधों में घोषित किए जाते हैं, और संबंध, मूल वर्ग के संबंध होते हैं।

 EmployeeWithCadreMovements -> relation(CadreMovement) -> field 

यदि संबंध मानों की सूची प्रदर्शित करता है, तो .any () का उपयोग किया जाना चाहिए, यदि केवल एक मूल्य प्रदान किया जाता है, तो .has () का उपयोग किया जाना चाहिए।

एक बेहतर समझ के लिए, इस निर्माण की व्याख्या SQL भाषा में मौजूद () निर्माण में की जाएगी।

हम कारण फ़ंक्शन पैरामीटर को उदाहरण के लिए, simple साथ फ़ंक्शन कहते हैं।

lesson6

 def has_in_relations(session: DBSession, reason: str): employees = session.query(EmployeeWithCadreMovements).filter(EmployeeWithCadreMovements.cadre_movements.any(CadreMovement.reason == reason)).all() return employees output: [Steve Rogers, Tony Stark] 

lession7

एकत्रीकरण फ़ंक्शन का उपयोग करके संबंध प्राप्त करने की संभावना पर विचार करें। उदाहरण के लिए, हमें किसी विशिष्ट उपयोगकर्ता का अंतिम कार्मिक आंदोलन मिलता है।
प्राइमरीजोन टेबल में शामिल होने के लिए एक शर्त है (यदि आलसी = 'ज्वाइन किया जाता है')। याद रखें कि चयन डिफ़ॉल्ट रूप से उपयोग किया जाता है।
इस स्थिति में, क्लास विशेषता को एक्सेस करते समय एक अलग अनुरोध उत्पन्न होता है। यह इस अनुरोध के लिए है कि हम फ़िल्टरिंग शर्तों को निर्दिष्ट कर सकते हैं।
जैसा कि आप जानते हैं, आप “शुद्ध” रूप में एकत्रीकरण कार्यों का उपयोग WHERE की स्थिति में नहीं कर सकते हैं, इसलिए हम संबंध निर्दिष्ट करके इस सुविधा को लागू कर सकते हैं
निम्नलिखित मापदंडों के साथ:

 last_cadre_movement = relation( CadreMovement, primaryjoin=and_( CadreMovement.employee == Employee.id, uselist=False, CadreMovement.id == select([func.max(CadreMovement.id)]).where(CadreMovement.employee == Employee.id) ) ) 

निष्पादित होने पर, अनुरोध इस तरह से संकलित होता है:

 SELECT cadre_movements.id AS cadre_movements_id, cadre_movements.created_at AS cadre_movements_created_at, cadre_movements.updated_at AS cadre_movements_updated_at, cadre_movements.employee AS cadre_movements_employee, cadre_movements.old_department AS cadre_movements_old_department, cadre_movements.new_department AS cadre_movements_new_department, cadre_movements.reason AS cadre_movements_reason FROM cadre_movements WHERE cadre_movements.employee = %(param_1)s AND cadre_movements.id = ( SELECT max(cadre_movements.id) AS max_1 FROM cadre_movements WHERE cadre_movements.employee = %(param_1)s ) 

जीथब लिंक

परिणाम

SQLAlchemy एक शक्तिशाली क्वेरी बिल्डिंग टूल है जो वंशानुक्रम का समर्थन करके विकास के समय को कम करता है।

लेकिन आपको ORM का उपयोग करने और जटिल प्रश्नों को लिखने के बीच एक महीन रेखा रखनी चाहिए। कुछ मामलों में, ORM डेवलपर को भ्रमित कर सकता है या कोड को बोझिल और अपठनीय बना सकता है।
सौभाग्य है