1.1 HQLకి పరిచయం
ఇంతకు ముందు, మీరు హైబర్నేట్తో పరిచయం కలిగి ఉన్నారు మరియు ఇప్పుడు నేను మీకు HQL , అకా హైబర్నేట్ క్వెరీ లాంగ్వేజ్ని పరిచయం చేస్తాను . వాస్తవానికి, ఇది హైబర్నేట్లో ప్రశ్నలను వ్రాయడానికి SQL మార్చబడింది. దీనికి అనేక కీలక తేడాలు ఉన్నాయి.
- పట్టిక పేరుకు బదులుగా తరగతి పేరును ఉపయోగించడం .
- టేబుల్ కాలమ్ పేరుకు బదులుగా క్లాస్ ఫీల్డ్ పేరును ఉపయోగించడం .
- ఎంపిక యొక్క ఐచ్ఛిక ఉపయోగం.
డేటాబేస్లో ఉన్న వినియోగదారులందరినీ మాకు తిరిగి ఇవ్వమని హైబర్నేట్ని అడుగుదాం. ఆ అభ్యర్థన ఎలా ఉంటుందో ఇక్కడ ఉంది:
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 |
---|---|
వినియోగదారు నుండి | యూజర్_డేటా నుండి * ఎంచుకోండి |
id=3 ఉన్న వినియోగదారు నుండి | id=3 ఉన్న user_data నుండి * ఎంచుకోండి |
వినియోగదారు నుండి స్థాయి (10,20,30) | user_level IN (10, 20, 30) ఉన్న user_data నుండి * ఎంచుకోండి |
సృష్టించబడిన asc ద్వారా వినియోగదారు ఆర్డర్ నుండి | user_created asc ద్వారా user_data ఆర్డర్ నుండి * ఎంచుకోండి |
వినియోగదారు నుండి 'పరీక్ష' వంటి పేరు | వినియోగదారు_డేటా నుండి *ని ఎంచుకోండి, ఇక్కడ 'పరీక్ష' వంటి వినియోగదారు_పేరు |
ప్రశ్నలు చాలా సారూప్యంగా ఉంటాయి మరియు మీకు క్లాస్ పేర్లు మరియు వాటి ఫీల్డ్లు తెలిసినప్పుడు HQL ప్రశ్నలను చదవడం SQL ప్రశ్నలను చదివినంత సులభం. ఇది వ్రాయడానికి కొంచెం కష్టంగా ఉండవచ్చు, కానీ మళ్ళీ, చాలా క్లిష్టమైన ప్రశ్నలు HQLలో చాలా అరుదుగా వ్రాయబడతాయి.
1.3 ఎంపికను ఉపయోగించడం
select
HQLలో, ఫలితం యొక్క డేటా రకం లో పేర్కొన్న రకంతో సరిపోలనప్పుడు మీరు ఉపయోగించవచ్చు 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();
}
}
ప్రశ్న తప్పనిసరిగా పేర్ల జాబితాను అందించాలని గుర్తుంచుకోండి. పేర్లు స్ట్రింగ్ టైప్లో ఉంటాయి, కాబట్టి ఫంక్షన్ రకం మరియు క్వెరీ క్లాస్ టైప్ పారామీటర్ రెండూ స్ట్రింగ్ టైప్లో ఉంటాయి.
GO TO FULL VERSION