@कई कई

सर्विस टेबल

अब आइए एक और सामान्य मामला देखें - अनेक-से-अनेक। आइए कल्पना करें कि हमारे कार्यों और कर्मचारियों के बीच कई-से-अनेक संबंध हैं :

• कर्मचारी तालिका में एक कर्मचारी कार्य तालिका से कई कार्य कर सकता है।
• कार्य तालिका में एक कार्य कई कर्मचारियों को सौंपा जा सकता है।

संस्थाओं के बीच इस संबंध को कई-से-कई कहा जाता है। और इसे SQL स्तर पर लागू करने के लिए, हमें एक अतिरिक्त सेवा तालिका की आवश्यकता है। आइए इसे कहते हैं, उदाहरण के लिए, कर्मचारी_कार्य।

कर्मचारी_कार्य तालिका में केवल दो कॉलम होंगे:

• कर्मचारी आयडी
• कार्य_आईडी

हर बार जब हम किसी विशिष्ट उपयोगकर्ता को कोई विशिष्ट कार्य सौंपते हैं, तो इस तालिका में एक नई पंक्ति जोड़ दी जाएगी। उदाहरण:

ठीक है, कार्य तालिका को अपना कर्मचारी_आईडी कॉलम खो देना चाहिए । यह तभी समझ में आता है जब कार्य केवल एक कर्मचारी को सौंपा जा सकता है। यदि कार्य कई कर्मचारियों को सौंपा जा सकता है, तो यह जानकारी कर्मचारी_कार्य सेवा तालिका में संग्रहीत की जानी चाहिए ।

टेबल-लेवल रिलेशनशिप

यहां बताया गया है कि हमारी नई टेबल कैसी दिखेंगी:

कर्मचारी तालिका ( नहीं बदला गया ) :

इस तालिका में निम्नलिखित स्तंभ हैं:

• आईडी आईएनटी
• वचरर नाम
• व्यवसाय VARCHAR
• वेतन आई.टी
• आयु आई.टी
• join_date DATE

और इस प्रकार कार्य तालिका दिखती है , कर्मचारी_आईडी कॉलम खो गया (लाल रंग में चिह्नित):

इस तालिका में अब केवल 3 स्तंभ हैं:

• आईडी - अद्वितीय कार्य संख्या (और तालिका में पंक्तियाँ)
• कर्मचारी_आईडी - (हटाया गया)
• नाम - कार्य का नाम और विवरण
• समय सीमा - जिस समय तक कार्य पूरा किया जाना चाहिए

हमारे पास कर्मचारी_कार्य सेवा तालिका भी है , जहां कर्मचारी_आईडी डेटा कार्य तालिका से माइग्रेट हो गया है:

मैंने जानबूझकर हटाए गए कॉलम को कार्य तालिका में अस्थायी रूप से सहेजा है ताकि आप देख सकें कि इससे डेटा कर्मचारी_कार्य तालिका में चला गया है।

एक अन्य महत्वपूर्ण बिंदु कर्मचारी_कार्य तालिका में लाल रेखा "(NULL) 6" है। मैंने इसे लाल रंग से चिह्नित किया है क्योंकि यह कर्मचारी_कार्य तालिका में नहीं होगा ।

यदि कार्य 7 को उपयोगकर्ता 4 को सौंपा गया है, तो कर्मचारी_कार्य तालिका में एक पंक्ति (4, 7) होनी चाहिए।

यदि कार्य 6 किसी को नहीं सौंपा गया है, तो कर्मचारी_कार्य तालिका में इसके लिए कोई रिकॉर्ड नहीं होगा। इन तालिकाओं के अंतिम संस्करण इस तरह दिखेंगे:

टास्क टेबल :

कर्मचारी_कार्य तालिका:

जावा वर्ग स्तर पर संचार

लेकिन इकाई-वर्गों के स्तर पर संचार के साथ, हमारे पास पूर्ण क्रम है। आइए अच्छी खबर के साथ शुरुआत करें।

सबसे पहले, हाइबरनेट में एक विशेष @ManyToMany एनोटेशन है जो आपको कई-से-अनेक तालिका संबंधों के मामले का अच्छी तरह से वर्णन करने की अनुमति देता है।

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

यहां बताया गया है कि हमारी कक्षाएं कैसी दिखेंगी। कर्मचारी वर्ग अपने मूल रूप में:

@Entity
@Table(name="user")
class Employee {
   @Column(name="id")
   public Integer id;

   @Column(name="name")
   public String name;

   @Column(name="occupation")
   public String occupation;

   @Column(name="salary")
   public Integer salary;

   @Column(name="join_date")
   public Date join;
}

और कर्मचारी कार्य वर्ग अपने मूल रूप में:

@Entity
@Table(name="task")
class EmployeeTask {
   @Column(name="id")
   public Integer id;

   @Column(name="name")
   public String description;

   @Column(name="deadline")
   public Date deadline;
}

@ManyToMany एनोटेशन

मैं उदाहरणों में मौजूदा क्षेत्रों को छोड़ दूंगा, लेकिन मैं नए जोड़ूंगा। यहां बताया गया है कि वे कैसे दिखेंगे। कर्मचारी वर्ग :

@Entity
@Table(name="employee")
class Employee {
   @Column(name="id")
   public Integer id;

   @ManyToMany(cascade = CascadeType.ALL)
   @JoinTable(name="employee_task",
	       joinColumns=  @JoinColumn(name="employee_id", referencedColumnName="id"),
           inverseJoinColumns= @JoinColumn(name="task_id", referencedColumnName="id") )
   private Set<EmployeeTask> tasks = new HashSet<EmployeeTask>();

}

और कर्मचारी कार्य वर्ग :

@Entity
@Table(name="task")
class EmployeeTask {
   @Column(name="id")
   public Integer id;

   @ManyToMany(cascade = CascadeType.ALL)
   @JoinTable(name="employee_task",
       	joinColumns=  @JoinColumn(name="task_id", referencedColumnName="id"),
       	inverseJoinColumns= @JoinColumn(name=" employee_id", referencedColumnName="id") )
   private Set<Employee> employees = new HashSet<Employee>();

}

ऐसा लगता है कि सब कुछ जटिल है, लेकिन वास्तव में सब कुछ सरल है।

सबसे पहले, यह @JoinTable एनोटेशन (@JoinColumn के साथ भ्रमित नहीं होना) का उपयोग करता है, जो कर्मचारी_कार्य सेवा तालिका का वर्णन करता है।

दूसरा, यह वर्णन करता है कि कर्मचारी_कार्य तालिका का कार्य_आईडी स्तंभ कार्य तालिका के आईडी स्तंभ को संदर्भित करता है।

तीसरा, यह कहता है कि कर्मचारी_कार्य तालिका का कर्मचारी_आईडी स्तंभ कर्मचारी तालिका के आईडी स्तंभ को संदर्भित करता है।

वास्तव में, एनोटेशन की मदद से, हमने बताया कि कर्मचारी_कार्य तालिका में कौन सा डेटा शामिल है और हाइबरनेट को इसकी व्याख्या कैसे करनी चाहिए।

लेकिन अब हम किसी भी कर्मचारी को बहुत आसानी से एक कार्य जोड़ (और हटा) सकते हैं। और किसी भी कार्य करने वाले को किसी भी कार्य में जोड़ें।

उदाहरणों का अनुरोध करें

आइए कुछ दिलचस्प प्रश्नों को बेहतर ढंग से समझने के लिए लिखते हैं कि ये मैनीटूमनी फील्ड कैसे काम करते हैं। और वे उम्मीद के मुताबिक ही काम करते हैं।

सबसे पहले, हमारा पुराना कोड बिना बदलाव के काम करेगा, क्योंकि निर्देशक के पास पहले एक कार्य क्षेत्र था:

EmployeeTask task1 = new EmployeeTask();
task1.description = "Do Something Important";
session.persist(task1);

EmployeeTask task2 = new EmployeeTask();
task2.description = "Nothing to do";
session.persist(task2);
session.flush();

Employee director = session.find(Employee.class, 4);
director.tasks.add(task1);
director.tasks.add(task2);

session.update(director);
session.flush();

दूसरे, यदि हम किसी अन्य कलाकार को किसी कार्य को सौंपना चाहते हैं, तो ऐसा करना और भी आसान है:

Employee director = session.find(Employee.class, 4);
EmployeeTask task = session.find(EmployeeTask.class, 101);
task.employees.add(director);

session.update(task);
session.flush();

महत्वपूर्ण! इस अनुरोध को निष्पादित करने के परिणामस्वरूप, न केवल कार्य में एक निष्पादक-निदेशक होगा, बल्कि निदेशक के पास कार्य संख्या 101 भी होगा।

सबसे पहले, कर्मचारी_कार्य तालिका में निदेशक और कार्य के बीच संबंध के बारे में तथ्य एक स्ट्रिंग के रूप में संग्रहीत किया जाएगा: (4,101)।

दूसरे, @ManyToMany एनोटेशन के साथ चिह्नित फ़ील्ड प्रॉक्सी ऑब्जेक्ट हैं, और जब उन्हें एक्सेस किया जाता है, तो डेटाबेस क्वेरी हमेशा निष्पादित होती है।

इसलिए यदि आप किसी कर्मचारी को कोई कार्य जोड़ते हैं और कर्मचारी के बारे में जानकारी डेटाबेस में सहेजते हैं, तो उसके बाद कार्य में निष्पादकों की सूची में एक नया निष्पादक होगा।