@ManyToMany

सेवा टेबल

आता आणखी एक सामान्य केस पाहू - अनेक ते अनेक. कल्पना करूया की कार्ये आणि कर्मचार्‍यांमध्ये आमचा अनेक-ते-अनेक संबंध आहे :

• कर्मचारी टेबलमधील एक कर्मचारी टास्क टेबलमधून अनेक कामे करू शकतो.
• टास्क टेबलमधील एक काम अनेक कर्मचाऱ्यांना नियुक्त केले जाऊ शकते.

घटकांमधील या संबंधाला अनेक-ते-अनेक म्हणतात. आणि ते SQL स्तरावर अंमलात आणण्यासाठी, आम्हाला अतिरिक्त सेवा सारणीची आवश्यकता आहे. चला, उदाहरणार्थ, कर्मचारी_टास्क म्हणू या.

कर्मचारी_कार्य सारणीमध्ये फक्त दोन स्तंभ असतील:

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

प्रत्येक वेळी आम्ही विशिष्ट वापरकर्त्याला विशिष्ट कार्य नियुक्त करतो तेव्हा, या सारणीमध्ये एक नवीन पंक्ती जोडली जाईल. उदाहरण:

बरं, टास्क टेबलने त्याचा कर्मचारी_आयडी स्तंभ गमावला पाहिजे . हे काम केवळ एका कर्मचाऱ्याला सोपवले जाऊ शकते तरच अर्थ प्राप्त होतो. जर कार्य अनेक कर्मचार्यांना नियुक्त केले जाऊ शकते, तर ही माहिती कर्मचारी_टास्क सर्व्हिस टेबलमध्ये संग्रहित केली जाणे आवश्यक आहे .

टेबल-स्तरीय संबंध

आमच्या नवीन सारण्या कशा दिसतील ते येथे आहे:

कर्मचारी टेबल ( बदललेले नाही ) :

या सारणीमध्ये खालील स्तंभ आहेत:

• आयडी INT
• VARCHAR नाव
• व्यवसाय VARCHAR
• पगार INT
• वय INT
• join_date DATE

आणि टास्क टेबल असे दिसते , हरवलेला कर्मचारी_आयडी स्तंभ (लाल रंगात चिन्हांकित):

या सारणीमध्ये आता फक्त 3 स्तंभ आहेत:

• id - अद्वितीय कार्य क्रमांक (आणि टेबलमधील पंक्ती)
• कर्मचारी_आयडी - (काढले)
• नाव - कार्याचे नाव आणि वर्णन
• अंतिम मुदत - कार्य पूर्ण होईपर्यंत वेळ

आमच्याकडे कर्मचारी_टास्क सेवा सारणी देखील आहे , जिथे कर्मचारी_आयडी डेटा कार्य सारणीवरून स्थलांतरित झाला आहे:

मी हेतुपुरस्सर हटवलेला कॉलम टास्क टेबलमध्‍ये तात्पुरता सेव्‍ह केला आहे जेणेकरून तुम्‍हाला त्‍यातील डेटा एम्प्लॉयी_टास्‍क टेबलमध्‍ये गेल्‍याचे दिसत आहे.

आणखी एक महत्त्वाचा मुद्दा म्हणजे कर्मचारी_टास्क टेबलमधील लाल रेषा "(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;
}

आणि EmployeeTask वर्ग त्याच्या मूळ स्वरूपात:

@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>();

}

आणि 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 सह गोंधळून जाऊ नये), जे कर्मचारी_टास्क सेवा सारणीचे वर्णन करते.

दुसरे, ते वर्णन करते की कर्मचारी_टास्क टेबलचा टास्क_आयडी कॉलम टास्क टेबलच्या आयडी कॉलमचा संदर्भ देते.

तिसरे, असे म्हणते की कर्मचारी_टास्क सारणीचा कर्मचारी_आयडी स्तंभ कर्मचारी टेबलच्या आयडी स्तंभाचा संदर्भ देतो.

खरं तर, भाष्यांच्या मदतीने, आम्ही एम्प्लॉयी_टास्क टेबलमध्ये कोणता डेटा समाविष्ट आहे आणि हायबरनेटने त्याचा कसा अर्थ लावावा याचे वर्णन केले आहे.

परंतु आता आम्ही कोणत्याही कर्मचाऱ्याला एखादे कार्य सहजपणे जोडू (आणि हटवू) शकतो. आणि कोणत्याही कार्यात कोणताही कलाकार जोडा.

उदाहरणांची विनंती करा

हे ManyToMany फील्ड कसे कार्य करतात हे चांगल्या प्रकारे समजून घेण्यासाठी काही मनोरंजक प्रश्न लिहूया. आणि ते अपेक्षेप्रमाणे काम करतात.

प्रथम, आमचा जुना कोड बदलांशिवाय कार्य करेल, कारण दिग्दर्शकाकडे आधी कार्य क्षेत्र होते:

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 भाष्यांसह चिन्हांकित फील्ड प्रॉक्सी ऑब्जेक्ट्स आहेत आणि जेव्हा ते ऍक्सेस केले जातात तेव्हा डेटाबेस क्वेरी नेहमी कार्यान्वित केली जाते.

म्हणून जर तुम्ही कर्मचार्‍याला एखादे कार्य जोडले आणि कर्मचार्‍याची माहिती डेटाबेसमध्ये जतन केली, तर त्यानंतर कार्याला एक्झिक्युटरच्या यादीत नवीन एक्झिक्युटर असेल.