@చాలా ఒకటి

2.1 పట్టిక స్థాయిలో లింక్ చేయడం

హైబర్నేట్ సేకరణలను సహాయక పట్టికలలో ఎలా నిల్వ చేస్తుందో మేము చూశాము. నిజమైన ఎంటిటీ తరగతులను నిల్వ చేసే పూర్తి స్థాయి పట్టికల మధ్య సంబంధాలను ఎలా నిర్వహించాలో ఇప్పుడు తెలుసుకుందాం.

హైబర్నేట్‌లో ఎంటిటీ తరగతుల మధ్య నాలుగు రకాల సంబంధాలు ఉన్నాయి:

• ఒకరి నుండి ఒకరు
• ఒకటి నుండి చాలా వరకు
• అనేక నుండి ఒకటి
• అనేక నుండి అనేక

మరియు మేము సరళమైన ఎంపికతో విశ్లేషణను ప్రారంభిస్తాము - అనేక నుండి ఒకటి .

మీరు ఇప్పటికే SQLలోని పట్టికల మధ్య అటువంటి సంబంధాన్ని చూశారు. ఇది సాధారణంగా కనిపించేది ఇక్కడ ఉంది:

ఉద్యోగుల పట్టిక:

ఈ పట్టిక కింది నిలువు వరుసలను కలిగి ఉంది:

• id INT
• పేరు VARCHAR
• వృత్తి VARCHAR
• జీతం INT
• వయస్సు INT
• చేరిన_తేదీ DATE

మరియు ఉద్యోగుల కోసం టాస్క్‌లను కలిగి ఉన్న టాస్క్ టేబుల్ ఇలా కనిపిస్తుంది:

ఈ పట్టికలో 4 నిలువు వరుసలు మాత్రమే ఉన్నాయి:

• id - ప్రత్యేకమైన పని సంఖ్య (మరియు పట్టికలోని వరుసలు);
• Employee_id - పనిని కేటాయించిన ఉద్యోగి పట్టిక నుండి ఉద్యోగి ID;
• పేరు - పని యొక్క పేరు మరియు వివరణ;
• గడువు - పనిని పూర్తి చేయవలసిన సమయం.

టాస్క్ టేబుల్‌లోని అనేక అడ్డు వరుసలు ఎంప్లాయ్ టేబుల్‌లోని ఒకే ఎంట్రీని సూచించగలవని మేము చూస్తాము. అటువంటి పట్టిక-స్థాయి సంబంధాన్ని అనేక నుండి ఒకటి అంటారు .

2.2 జావా తరగతి స్థాయికి సంబంధం

పట్టిక స్థాయిలో కమ్యూనికేషన్‌తో పాటు, మీరు హైబర్నేట్‌లోని ఎంటిటీ తరగతుల స్థాయిలో కూడా కమ్యూనికేషన్‌ని నిర్వహించవచ్చు. ఇది ఉల్లేఖనంతో చేయబడుతుంది @ManyToOne.

అయితే ముందుగా, కేవలం రెండు తరగతులను క్రియేట్ చేద్దాం: ఎంప్లాయీ మరియు ఎంప్లాయీ టాస్క్ :

@Entity
@Table(name="employee")
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="employee_id")
   public Integer employeeId;

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

ఈ తరగతులతో అంతా బాగానే ఉంది, కానీ ఎంప్లాయీ టాస్క్ క్లాస్‌లోని ఎంప్లాయీఐడి ఫీల్డ్ ఎంప్లాయీ క్లాస్ ఐడి ఫీల్డ్‌ను సూచిస్తుందనే వాస్తవాన్ని ప్రతిబింబించేలా వాటి మధ్య ఎలాంటి సంబంధం లేదు. ఇది సరిదిద్దడానికి సమయం

2.3 @ManyToOne ఉల్లేఖన.

మొదట, జావాలో మనం వాటి ఐడి కంటే ఆబ్జెక్ట్‌లపై (మరియు ఆబ్జెక్ట్ రిఫరెన్స్‌లు) ఆపరేట్ చేయడం అలవాటు చేసుకున్నాము. కాబట్టి ముందుగా, EmployeeTask క్లాస్‌లోని EmployeeId ఫీల్డ్‌కు బదులుగా, ఉద్యోగి రకం యొక్క వస్తువును సూచించండి. మా కొత్త తరగతి ఎలా ఉంటుందో ఇక్కడ ఉంది:

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

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

   @ManyToOne
   @JoinColumn(name = "employee_id")
   public Employee employee;

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

ఉల్లేఖన సహాయంతో @ManyToOne, అనేక EmployeeTask ఆబ్జెక్ట్‌లు ఉద్యోగి రకం యొక్క ఒక వస్తువును సూచించవచ్చని మేము సూచించాము. అలాగే, ఉల్లేఖనాన్ని ఉపయోగించి @JoinColumn, ఉద్యోగి ఆబ్జెక్ట్ యొక్క ఐడి మా టేబుల్‌లోని ఏ కాలమ్‌లో నిల్వ చేయబడిందో మేము సూచించాము.

2.4 అభ్యర్థన ఉదాహరణలు

అటువంటి సంబంధిత తరగతులతో హైబర్నేట్ ఎలా పని చేస్తుందో ఇప్పుడు కొన్ని ఉదాహరణలను చూపిద్దాం.

దృశ్యం ఒకటి

నిర్దిష్ట వినియోగదారుకు కేటాయించబడిన అన్ని పనులను కనుగొనడానికి ఒక ప్రశ్నను వ్రాస్దాం. HQLలో ఈ ప్రశ్న ఎలా ఉంటుందో ఇక్కడ ఉంది:

from EmployeeTask where employee.name = "Ivan Ivanovich"

మీరు కేవలం ఒక డాట్ ద్వారా డిపెండెంట్ క్లాస్‌ల ఫీల్డ్‌లను సూచించవచ్చు. ఇది చాలా సౌకర్యంగా ఉంటుంది. అయితే ఈ ప్రశ్నను జావా కోడ్ రూపంలో వ్రాద్దాం:

String hql = "from EmployeeTask where employee.name = :username";
Query<EmployeeTask> query = session.createQuery( hql, EmployeeTask.class);
query.setParameter("username", "Ivan Ivanovich");
List<EmployeeTask> resultLIst = query.list();

దృశ్యం రెండు

గడువు ముగిసిన టాస్క్‌లను కలిగి ఉన్న ఉద్యోగుల జాబితాను అందించే ప్రశ్నను వ్రాద్దాం. ఒక పని దాని గడువు గతంలో ఉన్నట్లయితే గడువు మీరిపోతుంది. SQLలో ఆ ప్రశ్న ఎలా ఉంటుందో ఇక్కడ ఉంది:

SELECT DISTINCT employee.*
FROM task JOIN employee ON task.employee_id = employee.id
WHERE task.deadline < CURDATE();

DISTINCTఒక వినియోగదారుకు అనేక పనులు కేటాయించబడవచ్చు కాబట్టి ఉపయోగించబడుతుంది.

ఇప్పుడు అదే ప్రశ్నను HQLలో వ్రాస్దాం:

select distinct employee from EmployeeTask where deadline < CURDATE();

ఈ ప్రశ్నలోని ఉద్యోగి అనేది EmployeeTask తరగతికి చెందిన ఫీల్డ్

పరిస్థితి మూడు

అప్పగించని పనులన్నీ డైరెక్టర్‌కి అప్పగించండి. SQL ప్రశ్న ఇలా కనిపిస్తుంది:

UPDATE task SET employee_id = 4 WHERE employee_id IS NULL

ఇప్పుడు అదే ప్రశ్నను HQLలో వ్రాస్దాం:

update EmployeeTask set employee = :user where employee is null

చివరి ప్రశ్న కష్టతరమైనది. మేము డైరెక్టర్ యొక్క IDని పాస్ చేయాలి, కానీ EmployeeTask క్లాస్‌లో మనం idని వ్రాయగలిగే ఫీల్డ్ లేదు, బదులుగా అది ఉద్యోగి ఫీల్డ్‌ని కలిగి ఉంటుంది, ఇక్కడ మేము ఉద్యోగి రకం యొక్క ఆబ్జెక్ట్‌కు సూచనను కేటాయించాలి.

Employee director = session.get(Employee.class, 4);

String hql = "update EmployeeTask set employee = :user where employee is null";
Query<EmployeeTask> query = session.createQuery(hql, EmployeeTask.class);
query.setParameter("user", director);
query.executeUpdate();