HQLలో ప్రశ్నలను వ్రాయడం నేర్చుకోవడం

1.1 HQLకి పరిచయం

ఇంతకు ముందు, మీరు హైబర్నేట్‌తో పరిచయం కలిగి ఉన్నారు మరియు ఇప్పుడు నేను మీకు HQL , అకా హైబర్నేట్ క్వెరీ లాంగ్వేజ్‌ని పరిచయం చేస్తాను . వాస్తవానికి, ఇది హైబర్నేట్‌లో ప్రశ్నలను వ్రాయడానికి SQL మార్చబడింది. దీనికి అనేక కీలక తేడాలు ఉన్నాయి.

1. పట్టిక పేరుకు బదులుగా తరగతి పేరును ఉపయోగించడం .
2. టేబుల్ కాలమ్ పేరుకు బదులుగా క్లాస్ ఫీల్డ్ పేరును ఉపయోగించడం .
3. ఎంపిక యొక్క ఐచ్ఛిక ఉపయోగం.

డేటాబేస్‌లో ఉన్న వినియోగదారులందరినీ మాకు తిరిగి ఇవ్వమని హైబర్నేట్‌ని అడుగుదాం. ఆ అభ్యర్థన ఎలా ఉంటుందో ఇక్కడ ఉంది:

from User

అంతే, పోలిక కోసం, మేము SQLలో ఇలాంటి ప్రశ్నను ప్రదర్శిస్తాము:

select * from user

ఇక్కడ Userతరగతి పేరు మరియు userపట్టిక పేరు.

పూర్తి జావా కోడ్ ఇలా కనిపిస్తుంది:

public List<User> getAllUsers() {
    try (Session session = sessionFactory.openSession()) {
            return session.createQuery("from User", User.class).list();
    }
}

లేకపోతే, HQL SQLకి చాలా పోలి ఉంటుంది - దీనికి ఆపరేటర్లు కూడా ఉన్నారు:

• WHERE
• ORDER BY
• GROUP BY
• HAVING

1.2 HQLతో పని చేయడానికి ఉదాహరణ

బహుశా మునుపటి ఉదాహరణ అదే పట్టిక మరియు ఫీల్డ్ పేర్ల కారణంగా కొంచెం గందరగోళంగా ఉండవచ్చు. ఇది సులభతరం అయ్యే ప్రత్యేక ఉదాహరణతో ముందుకు రండి.

కింది ఫీల్డ్‌లను కలిగి ఉన్న వినియోగదారు_డేటా పట్టికను కలిగి ఉన్నామని చెప్పండి :

• id INT
• వినియోగదారు పేరు VARCHAR(100)
• user_level INT
• DATE న వినియోగదారు_సృష్టించారు

మేము ఈ పట్టికకు మ్యాప్ చేసే జావా తరగతిని సృష్టిస్తాము:

@Entity
@Table(name="user_data")
class User {
   @Id
   @GeneratedValue
   public Integer id;
 
   @Column(name="user_name")
   public String name;
 
   @Column(name="user_level")
   public Integer level;
 
   @Column(name="user_created")
   public Date created;
}

ఇప్పుడు కొన్ని ఉదాహరణలు వ్రాద్దాం:

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

1.3 ఎంపికను ఉపయోగించడం

selectHQLలో, ఫలితం యొక్క డేటా రకం లో పేర్కొన్న రకంతో సరిపోలనప్పుడు మీరు ఉపయోగించవచ్చు from.

ఉదాహరణకు, మేము మా user_data పట్టికలో ఉన్న వినియోగదారులందరి పేర్లను పొందాలనుకుంటున్నాము , ఆపై మేము ఈ క్రింది ప్రశ్నను వ్రాయాలి:

select name from User

అలాగే, పేర్లలో నకిలీలు ఉంటే, మీరు ఆపరేటర్‌ని ఉపయోగించవచ్చు DISTINCT:

select distinct name from User

మారుపేర్లు SQLలో వలె పని చేస్తాయి:

select distinct u.name from User u where u.created > '2020-01-01'

బాగా, పూర్తిగా జావా కోడ్ రూపంలో, ఈ అభ్యర్థన ఇలా కనిపిస్తుంది:

public List<String> getUserNames() {
    try (Session session = sessionFactory.openSession()) {
            String hql = "select distinct u.name from User u where u.created > '2020-01-01'";
            Query<String> query = session.createQuery(hql , String.class);
            return query.list();
    }
}

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