ప్రశ్న తరగతిని అన్వేషించడం

2.1 ప్రశ్న తరగతులకు పరిచయం

మార్గం ద్వారా, మరొక ముఖ్యమైన విషయం ప్రశ్న సహాయక తరగతి. మీరు ఈ ఉదాహరణలో చూడవచ్చు:

public List<Employee> getAllEmployes() {
    try (Session session = sessionFactory.openSession()) {
            Query<Employee> query = session.createQuery("from Employee", Employee.class);
            return query.list();
    }
}

నిజానికి, క్వెరీ అనేది ఇంటర్‌ఫేస్ మరియు ఇది వివిధ సందర్భాల్లో అనేక అమలులను కలిగి ఉంది. కానీ సరళత కోసం, నేను దానిని క్లాస్ అని పిలుస్తాను. OOP పరంగా - ఇది ఒక విస్తృత కోణంలో ఒక తరగతి అని చెప్పండి.

గమనిక. ఒకప్పుడు రెండు తరగతులు ఉండేవి:

• ప్రశ్నను వివరించడానికి ప్రశ్న .
• తెలిసిన రకంతో ప్రశ్నను వివరించడానికి టైప్డ్ క్వెరీ .

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

కానీ, నాకు గుర్తున్నంత వరకు, హైబర్నేట్ యొక్క 5వ వెర్షన్‌తో ప్రారంభించి, ఒక టైప్ చేసిన క్లాస్ మాత్రమే మిగిలి ఉంది మరియు దానిని ఇప్పుడు క్వెరీ అంటారు.

ప్రశ్నను సృష్టించడానికి ప్రామాణిక మార్గం:

Query<Employee> query = session.createQuery("from Employee", Employee.class);

మీరు ప్రశ్న ఆబ్జెక్ట్‌లను ఎలా సృష్టించాలో నేర్చుకున్నారు, కానీ మీరు ఈ ప్రశ్నలను ఎలా అమలు చేస్తారు?

ఇది ఇక్కడ మరింత సరళమైనది - మేము ప్రశ్న ఆబ్జెక్ట్‌పై జాబితా() పద్ధతిని పిలుస్తాము:

Query<Employee> query = session.createQuery("from Employee", Employee.class);
List<Employee> resultLіst = query.list();

జాబితా() పద్ధతికి JPA పర్యాయపదం ఉంది, అదే పనిని చేసే పద్ధతిని getResultList() అంటారు . మీరు దీన్ని కొన్నిసార్లు ఇతర ప్రోగ్రామర్లు వ్రాసిన కోడ్‌లో చూడవచ్చు.

మార్గం ద్వారా, ఫలితం ఒకే ఫలితంలో ఉంటుందని ప్రశ్న సూచిస్తే, ప్రశ్నకు కాల్ చేయడానికి ఏకైక ఫలితాలు() పద్ధతిని ఉపయోగించడం సులభం .

Query<Employee> query = session.createQuery("from Employee where id = 1", Employee.class);
Employee result = query.uniqueResult();

ఏకైక ఫలితం() పద్ధతికి JPA పర్యాయపదం ఉంది, సింగిల్ రిజల్ట్() పద్ధతి . ఇది JPA ప్రమాణంతో హైబర్నేట్ అనుకూలత కోసం పరిచయం చేయబడింది. అతను సరిగ్గా అదే పని చేస్తాడు.

2.2 ప్రశ్న తరగతి పద్ధతులు

నిజానికి, క్వెరీ క్లాస్‌లో చాలా విభిన్న పద్ధతులు ఉన్నాయి. క్రింద నేను వాటిలో మూడు గురించి మాట్లాడతాను.

మొదటిది స్ట్రీమ్() పద్ధతి . మరియు దాని JPA పర్యాయపదం getResultStream() .

ఈ రెండు పద్ధతులు జాబితాకు బదులుగా డేటా స్ట్రీమ్‌ను అందిస్తాయి. ఒక ప్రశ్న ఫలితంగా పొందిన అన్ని వస్తువులు మీకు ఒకేసారి అవసరం లేనప్పుడు ఈ విధానం చాలా ప్రభావవంతంగా ఉంటుంది. లేదా వాటిలో మొదటిది మాత్రమే ఉపయోగించబడే అవకాశం ఉంది.

ఉదాహరణ:

Query<Employee> query = session.createQuery("from Employee where id > 100", Employee.class);
Stream<Employee> stream = query.stream();

రెండవ పద్ధతి executeUpdate() పద్ధతి . మీరు డేటాబేస్లో ఏదైనా మార్చే ప్రశ్నను వ్రాయవచ్చు. ఈ సందర్భంలో, డేటాబేస్ను యాక్సెస్ చేస్తున్నప్పుడు హైబర్నేట్ చదవడానికి మాత్రమే లావాదేవీని ఉపయోగించకుండా ఉండటం అవసరం.

అభ్యర్థన ఉదాహరణ: మేము వినియోగదారులందరి స్థాయిని 1 పెంచాలని నిర్ణయించుకున్నాము.

Query<User> query = session.createQuery("update User set level=level+1", User.class);
int count = query.executeUpdate();

executeUpdate() పద్ధతి వాస్తవానికి సవరించబడిన అడ్డు వరుసల సంఖ్యను అందిస్తుంది.

చివరకు మూడవ పద్ధతి స్క్రోల్() . మేము దాని గురించి కొంచెం ఎక్కువ చెబుతాము.

2.3 స్క్రోల్ క్లాస్ పద్ధతులు

ఈ పద్ధతి కొంతవరకు స్ట్రీమ్() పద్ధతిని పోలి ఉంటుంది . ఫలితాలను బయటకు తీయకుండా ఫలితాల జాబితా ద్వారా తరలించడానికి ఇది మాత్రమే మిమ్మల్ని అనుమతిస్తుంది. అంటే, మీరు ఒక ప్రశ్నను అమలు చేయవచ్చు, ఆపై దాన్ని ఫలితం యొక్క మిలియన్ల పంక్తికి స్క్రోల్ చేయండి మరియు అక్కడ నుండి డేటాను చదవడం ప్రారంభించండి.

అటువంటి అధునాతన ఇరేటర్.

Query<Employee> query = session.createQuery("from Employee where id > 100", Employee.class);
ScrollableResults<Employee> scroll = query.scroll();

ScrollableResults ఆబ్జెక్ట్ కింది పద్ధతులను కలిగి ఉంది:

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

Query<Employee> query = session.createQuery("from Employee where id > 100", Employee.class);
ScrollableResults<Employee> scroll = query.scroll();
scroll.last();
Employee lastEmployee = scroll.get();