క్రైటీరియా API పార్ట్ 2

గ్రూపింగ్ మరియు అగ్రిగేషన్ విధులు

Criteria APIకి సాధారణ అభ్యర్థనలు ఎలా చేయాలో మీరు ఇప్పటికే కనుగొన్నారు. మరింత క్లిష్టమైన ప్రశ్నలను ఎలా తయారు చేయాలో చూద్దాం.

ఉదాహరణకు, కంపెనీలో ఉద్యోగుల సంఖ్యను గుర్తించడానికి మేము ఒక ప్రశ్నను వ్రాయాలనుకుంటున్నాము. HQLలో ఇది ఎలా ఉంటుందో ఇక్కడ ఉంది:

select count(*) from Employee

మరియు క్రైటీరియా APIలో ఇలా:

CriteriaQuery<Long> critQuery = builder.createQuery(Long.class);
critQuery.select(builder.count(critQuery.from(Employee.class)));

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

CriteriaBuilder builder = session.getCriteriaBuilder();

CriteriaQuery<Long> critQuery = builder.createQuery(Long.class);
critQuery.select(builder.count(critQuery.from(Employee.class)));

Query<Long> query = session.createQuery(critQuery);
Long count = query.getSingleResult();

మరియు ఇది HQLని ఉపయోగించి అదే విధంగా ఉంటుంది:

String hqlQuery = "select count(*) from Employee";

Query<Long> query = session.createQuery(hqlQuery);
Long count = query.getSingleResult();

ఇప్పుడు కంపెనీలో సగటు జీతం లెక్కించేందుకు ప్రయత్నిద్దాం. HQL ప్రశ్న ఇలా కనిపిస్తుంది:

select avg(salary) from Employee

మరియు క్రైటీరియా APIలో ఇలా:

CriteriaQuery<Double> critQuery = builder.createQuery(Double.class);
critQuery.select(builder.avg( critQuery.from(Employee.class).get("salary")));

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

CriteriaBuilder builder = session.getCriteriaBuilder();

CriteriaQuery<Double> critQuery = builder.createQuery(Double.class);
critQuery.select(builder.avg( critQuery.from(Employee.class).get("salary")));

Query<Double> query = session.createQuery(critQuery);
Double avgSalary = query.getSingleResult();

ప్రమాణాలు నవీకరణ

పట్టికను సవరించడం దాని నుండి డేటాను పొందడం అంత సులభం. దీన్ని చేయడానికి, CriteriaBuilder ఒక ప్రత్యేక పద్ధతిని కలిగి ఉంది - createCriteriaUpdate() , ఇది ఒక వస్తువును సృష్టిస్తుందిప్రమాణాల నవీకరణ<T>డేటాబేస్‌లోని ఎంటిటీలను అప్‌డేట్ చేస్తుంది.

10 వేల లోపు పొందే ఉద్యోగుల జీతం పెంచుదాం. ఈ HQL ప్రశ్న ఎలా ఉంటుందో ఇక్కడ ఉంది:

update Employee set salary = salary+20000 where salary<=10000

మరియు ఇది క్రైటీరియా APIలో ఈ విధంగా కనిపిస్తుంది:

CriteriaUpdate<Employee> criteriaUpdate = builder.createCriteriaUpdate(Employee.class);
Root<Employee> root = criteriaUpdate.from(Employee.class);
criteriaUpdate.set("salary", "salary+20000");
criteriaUpdate.where(builder.lt(root.get("salary"), 10000));

Transaction transaction = session.beginTransaction();
session.createQuery(criteriaUpdate).executeUpdate();
transaction.commit();

ప్రమాణాలు తొలగించు

మరియు రికార్డులను మార్చడం కంటే వాటిని తొలగించడం చాలా సులభం. దీన్ని చేయడానికి, ఒక ప్రత్యేక పద్ధతి ఉంది createCriteriaDelete() , ఇది ఒక వస్తువును సృష్టిస్తుందిప్రమాణాలు తొలగించు<T>.

విలువ లేని ఉద్యోగులందరినీ కట్ చేద్దాం: వారి జీతం 10 వేల లోపే. ఈ HQL ప్రశ్న ఎలా ఉంటుందో ఇక్కడ ఉంది:

delete from Employee where salary<=10000

మరియు ఇది క్రైటీరియా APIలో ఈ విధంగా కనిపిస్తుంది:

CriteriaDelete<Employee> criteriaDelete = builder.createCriteriaDelete(Employee.class);
Root<Employee> root = criteriaDelete.from(Employee.class);
criteriaDelete.where(builder.lt(root.get("salary"), 10000));

Transaction transaction = session.beginTransaction();
session.createQuery(criteriaDelete).executeUpdate();
transaction.commit();

ప్రమాణాల API యొక్క ప్రయోజనాలు

కాబట్టి క్రైటీరియా API యొక్క ప్రయోజనం ఏమిటి? ప్రశ్నలు గజిబిజిగా ఉన్నాయి, HQL ఖచ్చితంగా మరింత కాంపాక్ట్‌గా ఉంటుంది.

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

String hqlQuery = "from Employee where salary < :sal";
Query<Employee> query = session.createQuery(hqlQuery);
query.setParametr("sal", 10000);
List<Employee> results = query.getResultList();

CriteriaBuilder builder = session.getCriteriaBuilder();
critQuery.select(critQuery.from(Employee.class)).where(builder.lt(root.get("salary"), 10000));
Query<Employee> query = session.createQuery(critQuery);
List<Employee> results = query.getResultList();

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

ఇక్కడ మీ పని ఉంది: ఒక నిర్దిష్ట వృత్తి (వృత్తి), జీతం (జీతం) మరియు ఉద్యోగ సంవత్సరం (YEAR (join_date)) ఉన్న ఉద్యోగులను ఎంచుకోవడం. కానీ ఏదైనా పరామితి విలువ శూన్యమైతే, దానిని ఫిల్టర్‌లో ఉపయోగించవద్దు.

అప్పుడు HQL ప్రశ్న ఇలా కనిపిస్తుంది:

from Employee
where (occupation = :ocp)
   	and (salary = :sal)
   	and ( YEAR(join_date) = :jny)

కానీ అది సరిగ్గా పని చేయదు, ఎందుకంటే "jny" పరామితి శూన్యంగా ఉంటే, అభ్యర్థన ఇలా కనిపిస్తుంది:

from Employee
where (occupation = :ocp)
   	and (salary = :sal)

శూన్యం కోసం పరామితిని తనిఖీ చేయడం ద్వారా మేము అభ్యర్థనను తిరిగి వ్రాయడానికి ప్రయత్నించవచ్చు, అప్పుడు మేము ఇలాంటివి పొందుతాము:

from Employee
where (occupation = :ocp or :ocp is null)
   	and (salary = :sal or :sal is null)
   	and ( YEAR(join_date)= :jny or :jny is null)

వాస్తవికత ఎంత క్లిష్టంగా మారుతుందో చూడండి? రియాలిటీ తరచుగా ఇలా ఉంటుంది :)

కానీ ఫిల్టర్ మరింత క్లిష్టంగా ఉంటుంది. "కొనుగోలు" అనే పదంతో టాస్క్‌లను కలిగి ఉన్న వినియోగదారుల కోసం శోధించడం ఎలా? లేదా మీరిచ్చిన టాస్క్‌లను కలిగి ఉన్న వినియోగదారులా?

from Employee
where (occupation = :ocp)
   	and (salary = :sal)
   	and (YEAR(join_date) = :jny)
   	and (tasks.name like '%buy%')
   	and (tasks.deadline < curdate())

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

కాబట్టి ఆచరణలో, మీరు అనేక పట్టికల ఫీల్డ్‌లలో ఏదైనా సంక్లిష్టమైన ఫిల్టర్‌ని చేసినప్పుడు, క్రైటీరియా API మీకు సహాయం చేస్తుంది. కాబట్టి అది వెళ్తుంది.

మరిన్ని వివరాలను అధికారిక డాక్యుమెంటేషన్‌లో చూడవచ్చు .