SQLAlchemy ORM - जॉइनिंग के साथ कार्य करना

अब जबकि हमारे पास दो टेबल हैं, हम देखेंगे कि एक ही समय में दोनों टेबलों पर क्वेरी कैसे बनाई जाए। ग्राहक और चालान के बीच एक सरल निहित जुड़ाव का निर्माण करने के लिए, हम उनके संबंधित कॉलम को समान करने के लिए Query.filter () का उपयोग कर सकते हैं। नीचे, हम इस पद्धति का उपयोग करते हुए ग्राहक और इनवॉइस संस्थाओं को लोड करते हैं -

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind = engine)
session = Session()

for c, i in session.query(Customer, Invoice).filter(Customer.id == Invoice.custid).all():
   print ("ID: {} Name: {} Invoice No: {} Amount: {}".format(c.id,c.name, i.invno, i.amount))

SQLAlchemy द्वारा उत्सर्जित SQL अभिव्यक्ति निम्नानुसार है -

SELECT customers.id 
AS customers_id, customers.name 
AS customers_name, customers.address 
AS customers_address, customers.email 
AS customers_email, invoices.id 
AS invoices_id, invoices.custid 
AS invoices_custid, invoices.invno 
AS invoices_invno, invoices.amount 
AS invoices_amount
FROM customers, invoices
WHERE customers.id = invoices.custid

और कोड की उपरोक्त पंक्तियों का परिणाम निम्नानुसार है -

ID: 2 Name: Gopal Krishna Invoice No: 10 Amount: 15000
ID: 2 Name: Gopal Krishna Invoice No: 14 Amount: 3850
ID: 3 Name: Govind Pant Invoice No: 3 Amount: 10000
ID: 3 Name: Govind Pant Invoice No: 4 Amount: 5000
ID: 4 Name: Govind Kala Invoice No: 7 Amount: 12000
ID: 4 Name: Govind Kala Invoice No: 8 Amount: 8500
ID: 5 Name: Abdul Rahman Invoice No: 9 Amount: 15000
ID: 5 Name: Abdul Rahman Invoice No: 11 Amount: 6000

वास्तविक SQL JOIN सिंटैक्स को Query.join () विधि का उपयोग करके आसानी से प्राप्त किया जाता है -

session.query(Customer).join(Invoice).filter(Invoice.amount == 8500).all()

शामिल होने के लिए एसक्यूएल अभिव्यक्ति कंसोल पर प्रदर्शित किया जाएगा -

SELECT customers.id 
AS customers_id, customers.name 
AS customers_name, customers.address 
AS customers_address, customers.email 
AS customers_email
FROM customers JOIN invoices ON customers.id = invoices.custid
WHERE invoices.amount = ?

हम परिणाम के माध्यम से लूप के लिए उपयोग कर सकते हैं -

result = session.query(Customer).join(Invoice).filter(Invoice.amount == 8500)
for row in result:
   for inv in row.invoices:
      print (row.id, row.name, inv.invno, inv.amount)

8500 बाइंड पैरामीटर के रूप में, निम्न आउटपुट प्रदर्शित होता है -

4 Govind Kala 8 8500

Query.join () जानता है कि इन तालिकाओं के बीच कैसे जुड़ना है क्योंकि उनके बीच केवल एक ही विदेशी कुंजी है। यदि कोई विदेशी कुंजी, या अधिक विदेशी कुंजियाँ नहीं थीं, तो Query.join () बेहतर काम करता है जब निम्न रूपों में से एक का उपयोग किया जाता है -

query.join (चालान, आईडी == Address.custid)	स्पष्ट स्थिति
query.join (Customer.invoices)	बाएं से दाएं संबंध निर्दिष्ट करें
query.join (चालान, Customer.invoices)	वही, स्पष्ट लक्ष्य के साथ
query.join ( 'चालान')	एक ही, एक स्ट्रिंग का उपयोग कर

इसी प्रकार, बाईं ओर बाहरी जुड़ाव प्राप्त करने के लिए आउटरजोइन () फ़ंक्शन उपलब्ध है।

query.outerjoin(Customer.invoices)

सबक्वेरी () पद्धति एक SQL अभिव्यक्ति का चयन करती है जो एक उपनाम के भीतर चयनित कथन का प्रतिनिधित्व करती है।

from sqlalchemy.sql import func

stmt = session.query(
   Invoice.custid, func.count('*').label('invoice_count')
).group_by(Invoice.custid).subquery()

Stmt ऑब्जेक्ट में नीचे SQL विवरण होगा -

SELECT invoices.custid, count(:count_1) AS invoice_count FROM invoices GROUP BY invoices.custid

एक बार जब हम अपना बयान देते हैं, तो यह एक टेबल निर्माण की तरह व्यवहार करता है। कथन पर कॉलम एक विशेषता के माध्यम से पहुँचा जा सकता है जिसे ग के रूप में नीचे दिए गए कोड में दिखाया गया है -

for u, count in session.query(Customer, stmt.c.invoice_count).outerjoin(stmt, Customer.id == stmt.c.custid).order_by(Customer.id):
   print(u.name, count)

लूप के लिए उपरोक्त चालान की नाम-वार गिनती प्रदर्शित करता है -

Arjun Pandit None
Gopal Krishna 2
Govind Pant 2
Govind Kala 2
Abdul Rahman 2