HQLలో చేరండి

3.1 మ్యాపింగ్ ఆధారిత ఎంటిటీలు

SQLలో, మీరు JOINని ఉపయోగించి ప్రశ్నలను వ్రాయవచ్చు. HQLలో కూడా అదే చేయడం సాధ్యమేనా? చిన్న సమాధానం అవును. అయితే పూర్తి సమాధానం మరింత ఆసక్తికరంగా ఉంటుంది.

మొదట, మనం SQLలో JOINని వ్రాసినప్పుడు, ఒక టేబుల్ మరొక పట్టికను సూచిస్తుందని దీని అర్థం. ఉదాహరణకు, టాస్క్ టేబుల్‌లో ఎంప్లాయ్ టేబుల్ ఐడి కాలమ్‌ని సూచించే ఉద్యోగి_ఐడి నిలువు వరుస ఉంటుంది.

హైబర్నేట్‌లోని ఉల్లేఖనాలను ఉపయోగించి ఈ డిపెండెన్సీని వివరించవచ్చు. ముందుగా, మన పట్టికల కోసం ఎంటిటీలను క్రియేట్ చేద్దాం. మొదట, ఉద్యోగి పట్టికను వివరించండి:

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

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

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

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

మరియు టాస్క్ టేబుల్ కోసం EmployeeTask క్లాస్ :

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

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

   @Column(name="employee_id")
   public Integer employeeId;

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

అంతా బాగానే ఉంది, కానీ ఒక సూచన ఉంది. చివరి ఉదాహరణలో EmployeeId ఫీల్డ్‌ని చూద్దాం :

@Column(name="employee_id")
public Integer employeeId;

మీరు ఏదైనా వింతగా గమనించారా? కాకపోతే, మీరు ఇప్పటికే SQL భాషలో ఆలోచనా విధానాన్ని రూపొందించుకున్నారని దీని అర్థం.

విషయం ఏమిటంటే, జావా భాషలో, మేము సాధారణంగా అలాంటి డిపెండెన్సీని కొద్దిగా భిన్నంగా వివరిస్తాము:

public Employee employee;

మేము idని పేర్కొనవలసిన అవసరం లేదు , మేము సాధారణంగా ఉద్యోగి ఆబ్జెక్ట్‌కు సూచనను కలిగి ఉన్న వేరియబుల్‌ని మాత్రమే పేర్కొంటాము . లేదా అలాంటి వస్తువు లేకుంటే శూన్యంగా నిల్వ చేస్తుంది.

మరియు హైబర్నేట్ ఉల్లేఖనాలను ఉపయోగించి అటువంటి పరిస్థితిని వివరించడానికి అనుమతిస్తుంది:

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

అనేక EmployeeTask ఎంటిటీలు ఒక ఉద్యోగి ఎంటిటీని సూచించవచ్చని ఉల్లేఖనం @ManyToOneహైబర్నేట్‌కి చెబుతుంది .

మరియు ఉల్లేఖనం ఐడి@JoinColumn తీసుకోబడే నిలువు వరుస పేరును నిర్దేశిస్తుంది . అన్ని ఇతర అవసరమైన సమాచారం ఉద్యోగి తరగతి యొక్క ఉల్లేఖనాల నుండి తీసుకోబడుతుంది.

తుది ఫలితం ఇలా కనిపిస్తుంది:

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

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

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

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

3.2 HQLలో చేరడాన్ని ఉపయోగించడం

మరియు ఇప్పుడు HQLలో సంబంధిత ఎంటిటీలకు ప్రశ్నలను ఎలా వ్రాయాలో చూద్దాం.

మొదటి పరిస్థితి.

మాకు ఒక ఉద్యోగి (ఉద్యోగి) ఉన్నారు మరియు మేము అతని పనుల జాబితాను పొందాలనుకుంటున్నాము. SQLలో ఆ ప్రశ్న ఎలా ఉంటుందో ఇక్కడ ఉంది:

SELECT task.* FROM task JOIN employee ON task.employee_id = employee.id
WHERE employee.name = "Ivan Ivanovich";

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

from EmployeeTask where employee.name = "Ivan Ivanovich"

EmployeeTask క్లాస్‌లో ఉద్యోగి ఫీల్డ్ ఉంది మరియు దీనికి పేరు ఫీల్డ్ ఉంది , కాబట్టి ఈ ప్రశ్న పని చేస్తుంది.

పరిస్థితి రెండు.

మీరిన విధులను కలిగి ఉన్న ఉద్యోగుల జాబితాను తిరిగి ఇవ్వండి. 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ని వ్రాయగలిగే ఫీల్డ్ లేదు, బదులుగా అది ఉద్యోగి ఫీల్డ్‌ని కలిగి ఉంది, ఇక్కడ మీరు ఉద్యోగి రకం యొక్క ఆబ్జెక్ట్‌కు సూచనను కేటాయించాలి.

హైబర్నేట్‌లో, ప్రశ్న ఆబ్జెక్ట్‌కు పంపబడే ప్రశ్న పారామితుల సహాయంతో ఈ సమస్య పరిష్కరించబడుతుంది. మరియు HQLలోనే, అటువంటి పారామితులు పెద్దప్రేగు ద్వారా వ్రాయబడతాయి: :user. కానీ మేము దీని గురించి కొంచెం తరువాత మాట్లాడుతాము.