बहुत से रिश्ते

Many to Many relationshipदो तालिकाओं के बीच एक संघ तालिका जोड़कर हासिल की जाती है, जैसे कि इसमें दो विदेशी कुंजियाँ हों - प्रत्येक तालिका की प्राथमिक कुंजी से एक। इसके अलावा, दो तालिकाओं की मैपिंग करने वाली कक्षाओं में एक विशेषता होती है, जिसे संबंध की माध्यमिक विशेषता () फ़ंक्शन के रूप में सौंपी गई अन्य एसोसिएशन तालिकाओं की वस्तुओं के संग्रह के साथ होती है।

इस प्रयोजन के लिए, हम दो तालिकाओं - विभाग और कर्मचारी के साथ एक SQLite डेटाबेस (mycollege.db) बनाएंगे। यहां, हम मानते हैं कि एक कर्मचारी एक से अधिक विभाग का हिस्सा है, और एक विभाग में एक से अधिक कर्मचारी हैं। यह कई-से-कई संबंधों का गठन करता है।

विभाग और कर्मचारी तालिका के लिए कर्मचारी और विभाग वर्गों की परिभाषा निम्नानुसार है -

from sqlalchemy import create_engine, ForeignKey, Column, Integer, String
engine = create_engine('sqlite:///mycollege.db', echo = True)
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
from sqlalchemy.orm import relationship

class Department(Base):
   __tablename__ = 'department'
   id = Column(Integer, primary_key = True)
   name = Column(String)
   employees = relationship('Employee', secondary = 'link')
   
class Employee(Base):
   __tablename__ = 'employee'
   id = Column(Integer, primary_key = True)
   name = Column(String)
   departments = relationship(Department,secondary='link')

अब हम एक लिंक क्लास को परिभाषित करते हैं। यह लिंक टेबल से जुड़ा हुआ है और इसमें विभाग और कर्मचारी तालिका की प्राथमिक कुंजियों का संदर्भ देते हुए क्रमशः विभाग_आईडी और कर्मचारी_ सहायता विशेषताएँ सम्‍मिलित हैं।

class Link(Base):
   __tablename__ = 'link'
   department_id = Column(
      Integer, 
      ForeignKey('department.id'), 
      primary_key = True)

employee_id = Column(
   Integer, 
   ForeignKey('employee.id'), 
   primary_key = True)

यहां, हमें यह नोट करना होगा कि विभाग वर्ग में कर्मचारी वर्ग से संबंधित कर्मचारी विशेषता है। संबंध फ़ंक्शन की द्वितीयक विशेषता को उसके मूल्य के रूप में एक लिंक सौंपा गया है।

इसी प्रकार, कर्मचारी वर्ग में विभाग वर्ग से संबंधित विभाग विशेषता है। संबंध फ़ंक्शन की द्वितीयक विशेषता को उसके मूल्य के रूप में एक लिंक सौंपा गया है।

इन सभी तीन तालिकाओं को बनाया जाता है जब निम्नलिखित कथन निष्पादित किया जाता है -

Base.metadata.create_all(engine)

पायथन कंसोल क्रिएट टेबल प्रश्नों का अनुसरण करता है -

CREATE TABLE department (
   id INTEGER NOT NULL,
   name VARCHAR,
   PRIMARY KEY (id)
)

CREATE TABLE employee (
   id INTEGER NOT NULL,
   name VARCHAR,
   PRIMARY KEY (id)
)

CREATE TABLE link (
   department_id INTEGER NOT NULL,
   employee_id INTEGER NOT NULL,
   PRIMARY KEY (department_id, employee_id),
   FOREIGN KEY(department_id) REFERENCES department (id),
   FOREIGN KEY(employee_id) REFERENCES employee (id)
)

हम नीचे दिए गए स्क्रीनशॉट में दिखाए अनुसार SQLiteStudio का उपयोग करके mycollege.db को खोलकर इसकी जांच कर सकते हैं -

आगे हम विभाग की तीन वस्तुओं और कर्मचारी वर्ग की तीन वस्तुओं का निर्माण करते हैं जैसा कि नीचे दिखाया गया है -

d1 = Department(name = "Accounts")
d2 = Department(name = "Sales")
d3 = Department(name = "Marketing")

e1 = Employee(name = "John")
e2 = Employee(name = "Tony")
e3 = Employee(name = "Graham")

प्रत्येक तालिका में एक संग्रह विशेषता है जिसमें एपेंड () विधि है। हम कर्मचारी ऑब्जेक्ट को विभाग वस्तु के कर्मचारी संग्रह में जोड़ सकते हैं। इसी प्रकार, हम डिपार्टमेंट ऑब्जेक्ट्स को डिपार्टमेंट्स एम्प्लॉई ऑब्जेक्ट्स की विशेषता संग्रह में जोड़ सकते हैं।

e1.departments.append(d1)
e2.departments.append(d3)
d1.employees.append(e3)
d2.employees.append(e2)
d3.employees.append(e1)
e3.departments.append(d2)

अब हमें केवल एक सत्र ऑब्जेक्ट सेट करना है, सभी ऑब्जेक्ट्स को इसमें जोड़ना है और नीचे दिखाए अनुसार बदलाव करना है -

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind = engine)
session = Session()
session.add(e1)
session.add(e2)
session.add(d1)
session.add(d2)
session.add(d3)
session.add(e3)
session.commit()

निम्नलिखित SQL बयान पायथन कंसोल पर उत्सर्जित किए जाएंगे -

INSERT INTO department (name) VALUES (?) ('Accounts',)
INSERT INTO department (name) VALUES (?) ('Sales',)
INSERT INTO department (name) VALUES (?) ('Marketing',)
INSERT INTO employee (name) VALUES (?) ('John',)
INSERT INTO employee (name) VALUES (?) ('Graham',)
INSERT INTO employee (name) VALUES (?) ('Tony',)
INSERT INTO link (department_id, employee_id) VALUES (?, ?) ((1, 2), (3, 1), (2, 3))
INSERT INTO link (department_id, employee_id) VALUES (?, ?) ((1, 1), (2, 2), (3, 3))

उपरोक्त कार्यों के प्रभाव की जांच करने के लिए, SQLiteStudio का उपयोग करें और डेटा को विभाग, कर्मचारी और लिंक तालिकाओं में देखें -

डेटा प्रदर्शित करने के लिए, निम्नलिखित क्वेरी स्टेटमेंट चलाएं -

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

for x in session.query( Department, Employee).filter(Link.department_id == Department.id, 
   Link.employee_id == Employee.id).order_by(Link.department_id).all():
   print ("Department: {} Name: {}".format(x.Department.name, x.Employee.name))

हमारे उदाहरण में आबादी के अनुसार, आउटपुट नीचे प्रदर्शित किया जाएगा -

Department: Accounts Name: John
Department: Accounts Name: Graham
Department: Sales Name: Graham
Department: Sales Name: Tony
Department: Marketing Name: John
Department: Marketing Name: Tony