ప్రమాణం API

ప్రమాణాల APIకి పరిచయం

హైబర్నేట్‌లో డేటాబేస్ ప్రశ్నలను వ్రాయడానికి రెండు మార్గాలు ఉన్నాయి:

• హైబర్నేట్ ప్రశ్న భాష
• ప్రమాణం API

మీరు ఇప్పటికే చాలా కాలం క్రితం మొదటిదాన్ని కలుసుకున్నారు, ఇది క్రైటీరియా APIతో పరిచయం పొందడానికి సమయం ఆసన్నమైంది. ఇది చాలా శక్తివంతమైన సాధనం, ఏదో ఒక సమయంలో ఇది HQL కంటే ఎక్కువ జనాదరణ పొందింది. ఇప్పుడు ఇది అంతగా ప్రాచుర్యం పొందలేదు, కానీ కొన్ని పనులకు ఇది ఖచ్చితంగా HQL కంటే మెరుగైన పరిష్కారం అవుతుంది.

ఏ సందర్భంలోనైనా, మీరు క్రైటీరియా APIతో పరిచయం లేకుండా హైబర్నేట్ నేర్చుకోలేరు. ఒక చిన్న ఉదాహరణ వ్రాస్దాం, ఆపై మేము దానిని విశ్లేషిస్తాము. ఉదాహరణకు, మేము డేటాబేస్ నుండి ఉద్యోగులందరినీ (ఉద్యోగి) అభ్యర్థిస్తాము. మేము పొందేది ఇక్కడ ఉంది:

CriteriaBuilder builder = session.getCriteriaBuilder();
CriteriaQuery<Employee> critQuery = builder.createQuery(Employee.class);

Root<Employee> root = critQuery.from(Employee.class);
critQuery.select(root);

Query<Employee> query = session.createQuery(critQuery);
List<Employee> results = query.getResultList();

సంక్లిష్టంగా కనిపిస్తుంది. పోలిక కోసం అదే HQL ప్రశ్నను వ్రాస్దాం:

String hqlQuery = "from Employee";

Query<Employee> query = session.createQuery(hqlQuery);
List<Employee> results = query.getResultList();

రెండు ఉదాహరణలలోని చివరి రెండు పంక్తులు దాదాపు ఒకేలా ఉన్నాయని గమనించండి: మేము ప్రశ్న ఆబ్జెక్ట్‌ని సృష్టించి, జాబితాను పొందడానికి దాన్ని ఉపయోగిస్తాము. మిగిలిన పంక్తులు ఏదో ఒకేలా చేస్తున్నాయని ఇది సూచిస్తుంది.

మొదటి ఉదాహరణలో 3 మరియు 4 పంక్తులను చూడండి:

Root<Employee> root = critQuery.from(Employee.class);
critQuery.select(root);

వాటిని ఒకే వరుసలో వ్రాస్దాం:

critQuery.select(critQuery.from(Employee.class));

ఇది మీకు ఏదైనా గుర్తు చేయలేదా? మరియు మీరు దానిని కొద్దిగా భిన్నంగా రంగు వేస్తే:

critQuery.select(critQuery.from(Employee.class));

అవును, ఇది SELECT FROM ప్రశ్న యొక్క గమ్మత్తైన నిర్మాణం.

క్రైటీరియా APIతో పని చేసే ఉదాహరణలు

మంచి అవగాహన కోసం, నేను కొన్ని ఉదాహరణలు ఇస్తాను.

అభ్యర్థన 1 . 10 వేల కంటే ఎక్కువ జీతం ఉన్న ఉద్యోగులందరినీ పొందండి:

critQuery.select(critQuery.from(Employee.class)).where(builder.gt(root.get("salary"), 10000));

అభ్యర్థన 2 . 50 వేల కంటే తక్కువ జీతం ఉన్న ఉద్యోగులందరినీ పొందండి:

critQuery.select(critQuery.from(Employee.class)).where(builder.lt(root.get("salary"), 50000));

అభ్యర్థన 3 . ఉద్యోగ శీర్షికలో "పరీక్ష" అనే పదం ఉన్న ఉద్యోగులందరినీ పొందండి:

critQuery.select(critQuery.from(Employee.class)).where(builder.like(root.get("occupation"), "%test%"));

అభ్యర్థన 4 . 10 నుండి 50 వేల జీతంతో ఉద్యోగులందరినీ పొందండి:

critQuery.select(critQuery.from(Employee.class)).where(builder.between(root.get("salary"), 10000, 50000));

అభ్యర్థన 5 . పేరు శూన్యమైన ఉద్యోగులందరినీ పొందండి:

critQuery.select(critQuery.from(Employee.class)).where(builder.isNull(root.get("name")));

అభ్యర్థన 6 . పేరు శూన్యం కాని ఉద్యోగులందరినీ పొందండి:

critQuery.select(critQuery.from(Employee.class)).where(builder.isNotNull(root.get("name")));

ప్రశ్నను రూపొందించడానికి ఇది చాలా గమ్మత్తైన మార్గం:

• మొదట మీరు వస్తువును పొందండిక్రైటీరియా బిల్డర్.
• ఆపై ఒక వస్తువును సృష్టించడానికి దాన్ని ఉపయోగించండిప్రమాణం ప్రశ్న.
• అప్పుడు మీరు దానితో భాగాలను జోడించడం ప్రారంభించండిప్రమాణం ప్రశ్నమరియుక్రైటీరియా బిల్డర్.

మీరు దీని కోసం పారామితులను ఈ విధంగా సెట్ చేయవచ్చు:

• ఎంచుకోండి
• నుండి
• ఎక్కడ

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

క్రైటీరియా APIతో అధునాతన పని

క్రైటీరియా APIని ఉపయోగించి, మీరు ఏదైనా సంక్లిష్టత యొక్క ప్రశ్నను నిర్మించవచ్చు. మరియు ఇది గొప్ప వార్త. ఉదాహరణకు, మీకు సంక్లిష్టమైన WHERE నిబంధన కావాలి. దీన్ని ఎలా చేయాలో ఇక్కడ ఉంది:

Predicate greaterThan = builder.gt(root.get("salary"), 1000);
Predicate testers = builder.like(root.get("occupation"), "test%");

critQuery.select(critQuery.from(Employee.class)).where(builder.or(greaterThan, testers));

మీరు ORకి బదులుగా AND అని వ్రాయాలనుకుంటే, మీరు చివరి పంక్తిని మాత్రమే మార్చాలి:

critQuery.select(critQuery.from(Employee.class)).where(builder.and(greaterThan, testers));

ప్రతిదీ నిజానికి చాలా సులభం. నేను మీకు కొన్ని పోలికలతో పట్టికను ఇస్తాను:

ప్రతిదీ సులభం, కాదా?

మరియు ప్రశ్నకు క్రమబద్ధీకరణను ఎలా జోడించాలి? చాలా సులభం:

critQuery.select( critQuery.from(Employee.class) );
critQuery.where( builder.and(greaterThan, testers) );
critQuery.orderBy( builder.asc(root.get("salary"), builder.desc(root.get("joinDate") )

మీరు ఆబ్జెక్ట్‌ని పిలవండిప్రమాణం ప్రశ్నorderBy() పద్ధతి మరియు దానికి అవసరమైన పారామితులను పాస్ చేయండి.

HQLలో అదే ప్రశ్న ఎలా ఉంటుందో ఇక్కడ ఉంది. సరిపోల్చండి:

select * from Employee
where (…) and (…)
order by 'salary' asc, 'joinDate' desc

మీరు కేవలం 3 విషయాలను గుర్తుంచుకోవాలి:

• SELECT, FROM, WHERE వంటి కీలక ఆపరేటర్‌లు ఒక వస్తువుపై పిలువబడతాయిప్రమాణం ప్రశ్న.
• ఆబ్జెక్ట్‌పై AND, OR, DESC వంటి సహాయక ఆపరేటర్‌లను పిలుస్తారుక్రైటీరియా బిల్డర్.
• ఫీల్డ్ పేర్లు వస్తువు నుండి get() ద్వారా తీసుకోబడ్డాయిరూట్.