@MyToMany

சேவை அட்டவணை

இப்போது மற்றொரு பொதுவான வழக்கைப் பார்ப்போம் - பல முதல் பல. பணிகளுக்கும் பணியாளர்களுக்கும் இடையே பல-பல உறவுகள் உள்ளன என்று கற்பனை செய்து கொள்வோம் :

• பணியாளர் அட்டவணையில் உள்ள ஒரு பணியாளர் பணி அட்டவணையில் இருந்து பல பணிகளைச் செய்ய முடியும்.
• பணி அட்டவணையில் ஒரு பணி பல ஊழியர்களுக்கு ஒதுக்கப்படலாம்.

நிறுவனங்களுக்கிடையிலான இந்த உறவு பல முதல் பல என்று அழைக்கப்படுகிறது. SQL மட்டத்தில் அதைச் செயல்படுத்த, எங்களுக்கு கூடுதல் சேவை அட்டவணை தேவை. எடுத்துக்காட்டாக, Employee_task என்று அழைப்போம்.

பணியாளர்_பணி அட்டவணையில் இரண்டு நெடுவரிசைகள் மட்டுமே இருக்கும்:

• பணியாளர்_ஐடி
• பணி_ஐடி

ஒவ்வொரு முறையும் ஒரு குறிப்பிட்ட பயனருக்கு ஒரு குறிப்பிட்ட பணியை ஒதுக்கும்போது, ​​இந்த அட்டவணையில் ஒரு புதிய வரிசை சேர்க்கப்படும். உதாரணமாக:

சரி, பணி அட்டவணை அதன் பணியாளர்_ஐடி நெடுவரிசையை இழக்க வேண்டும் . பணியை ஒரு பணியாளருக்கு மட்டுமே வழங்க முடியும் என்றால் அது அர்த்தமுள்ளதாக இருக்கும். பணியை பல ஊழியர்களுக்கு ஒதுக்க முடியுமானால், இந்தத் தகவல் பணியாளர்_பணி சேவை அட்டவணையில் சேமிக்கப்பட வேண்டும் .

அட்டவணை-நிலை உறவு

எங்கள் புதிய அட்டவணைகள் எப்படி இருக்கும் என்பது இங்கே:

பணியாளர் அட்டவணை ( மாற்றப்படவில்லை ) :

இந்த அட்டவணையில் பின்வரும் நெடுவரிசைகள் உள்ளன:

• ஐடி INT
• பெயர் VARCHAR
• தொழில் VARCHAR
• சம்பளம் INT
• வயது INT
• join_date DATE

பணி அட்டவணை இப்படித்தான் தெரிகிறது , ஊழியர்_ஐடி நெடுவரிசையை இழந்தது (சிவப்பு நிறத்தில் குறிக்கப்பட்டுள்ளது):

இந்த அட்டவணையில் இப்போது 3 நெடுவரிசைகள் மட்டுமே உள்ளன:

• ஐடி - தனிப்பட்ட பணி எண் (மற்றும் அட்டவணையில் உள்ள வரிசைகள்)
• ஊழியர்_ஐடி - (அகற்றப்பட்டது)
• பெயர் - பணியின் பெயர் மற்றும் விளக்கம்
• காலக்கெடு - பணியை முடிக்க வேண்டிய நேரம்

எங்களிடம் பணியாளர்_பணி சேவை அட்டவணையும் உள்ளது , அங்கு பணி அட்டவணையில் இருந்து பணியாளர்_ஐடி தரவு இடம்பெயர்ந்தது:

பணி அட்டவணையில் நீக்கப்பட்ட நெடுவரிசையை நான் வேண்டுமென்றே தற்காலிகமாகச் சேமித்தேன், இதன் மூலம் அதிலிருந்து தரவு ஊழியர்_பணி அட்டவணைக்கு நகர்த்தப்பட்டிருப்பதை நீங்கள் பார்க்கலாம்.

மற்றொரு முக்கியமான புள்ளி , பணியாளர்_பணி அட்டவணையில் சிவப்பு கோடு "(NULL) 6" ஆகும். இது Employee_task அட்டவணையில் இருக்காது என்பதால் சிவப்பு நிறத்தில் குறியிட்டுள்ளேன் .

பணி 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;
}

@MyToMany சிறுகுறிப்பு

எடுத்துக்காட்டுகளில் இருக்கும் புலங்களை நான் தவிர்த்துவிடுவேன், ஆனால் புதியவற்றைச் சேர்ப்பேன். அவர்கள் எப்படி இருப்பார்கள் என்பது இங்கே. பணியாளர் வகுப்பு :

@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 உடன் குழப்பமடையக்கூடாது), இது Employee_task சேவை அட்டவணையை விவரிக்கிறது.

இரண்டாவதாக, பணியாளர்_பணி அட்டவணையின் task_id நெடுவரிசை பணி அட்டவணையின் ஐடி நெடுவரிசையைக் குறிக்கிறது என்று இது விவரிக்கிறது.

மூன்றாவதாக, பணியாளர்_பணி அட்டவணையின் Employee_id நெடுவரிசையானது பணியாளர் அட்டவணையின் ஐடி நெடுவரிசையைக் குறிக்கிறது என்று அது கூறுகிறது.

உண்மையில், சிறுகுறிப்புகளின் உதவியுடன், பணியாளர்_பணி அட்டவணையில் என்ன தரவு உள்ளது மற்றும் அதை ஹைபர்னேட் எவ்வாறு விளக்க வேண்டும் என்பதை விவரித்தோம்.

ஆனால் இப்போது நாம் எந்த ஒரு பணியாளரிடமும் மிக எளிதாக ஒரு பணியைச் சேர்க்கலாம் (அழிக்கலாம்). மேலும் எந்த ஒரு பணியாளரையும் எந்த பணியிலும் சேர்க்கவும்.

உதாரணங்களைக் கோருங்கள்

இந்த 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 சிறுகுறிப்புகளுடன் குறிக்கப்பட்ட புலங்கள் ப்ராக்ஸி பொருள்கள், அவற்றை அணுகும்போது, ​​தரவுத்தள வினவல் எப்போதும் செயல்படுத்தப்படும்.

எனவே நீங்கள் ஒரு பணியாளருக்கு ஒரு பணியைச் சேர்த்து, பணியாளரைப் பற்றிய தகவல்களை தரவுத்தளத்தில் சேமித்தால், அதன் பிறகு பணியை நிறைவேற்றுபவர்களின் பட்டியலில் ஒரு புதிய நிர்வாகி இருக்கும்.