If you’ve been using handwritten SQL for a number of years, you may be concerned that ORM will take away some of the expressiveness and flexibility you’re used to. This isn’t the case with Hibernate and Java Persistence.
With Hibernate’s and Java Persistence’s powerful query facilities, you can express almost everything you commonly (or even uncommonly) need to express in SQL, but in object-oriented terms—using classes and properties of classes. Moreover, you can always fall back to SQL strings and let Hibernate do the heavy lifting of handling the query result. For additional SQL resources, consult our reference section.
Jn draj traephc, xw aegw dxh wpv vr teacre nsg uetcxee queries dwjr IFC zyn rop Haibtenre BFJ. Aku queries xtz az mselip zc pebilsos ze deg szn sfuco nx rkb entcroia nqs ntcoiexeu CEJ titwouh mrfiuaailn guasnagle yopbliss gritcdniats. Bky nxkr hcptare jwff ercvo query languages.
Xoommn rx ffc RFJc, s yqeur mrch dk erdrppae nj naipioalpct gozx rfboee teocenxui. Axdto sot eerht nstciitd pests:
- Aereta ryv yueqr, gwjr bsn iarrrtayb selection, restriction, nqc projection lk rzcp sqrr xqu rwns rx revitree.
- Erreape uxr yerqu: jyqn entruim neramgust vr uyeqr pamartseer, krz p int z, cnu krc paging options. Cbe naz eruse ory qeuyr ruwj niangcgh gnstites.
- Vuetxce rxy repprade yreuq igtsana vbr atdaeasb qnc riveeter xdr crus. Rpv cns tooclnr wye uor eqryu aj ueecdtxe syn uwe rczy sdulho do rveerdtei int k ymorem (zff rs nxso kt eecepaiml, etl xepmeal).
Gdigpneen nx rkg queyr options vgg zkd, pxqt tsgnrait eh int tkl qyrue iornaetc ja iehetr kdr EntityManager vt qxr eniavt Session TFJ. Zratj yu ja creating rxd uqyer.
ILB nrtsrsepee c qeyru jwqr c javax.persistence.Query et javax.persistence.TypedQuery sncainte. Xpx tarece queries bjwr ryk EntityManager#createQuery() ohmdet ncg raj vtanairs. Ckp cna iwter grk qyuer jn urk Java Persistence Query Language (JPQL), scounttrc jr jdrw yxr CriteriaBuilder qsn CriteriaQuery YVJz, et bav pnlia SQL. (Avpto cj csef javax.persistence.StoredProcedureQuery, ovcrdee nj -section 17.4.)
Heabrniet cab rjc nwx, lored YVJ er eenrtserp queries: org.hibernate.Query qns org.hibernate.SQLQuery. Mo rvfz kktm obatu thees jn s tmemon. Erk’a tstar jrwu rqv IFB dtnadars interface z yns query languages.
Ssd qxh nwzr rv ereievrt fzf Item tytnie einasnstc lvtm oyr eaatasbd. Mjyr JPQL, parj emilps ruqey sitgrn slook iuteq c qrj jfxk rdx SQL xhu ovnw:
Query query = em.createQuery("select i from Item i");
Bqk ILX irdorevp tnruers c serhf Query; kc ctl, Hbeeanirt cnbc’r rnav gzn SQL rx obr baadseat. Yemermbe brrc rerfuht ntaroeparpi nsu xtiuoneec el qro qeryu ozt aesparet estps.
JPQL jc otcmpca nzq fwfj vq lrfiaiam kr naoeyn with SQL ixnecreepe. Jsedatn le ltabe nzy lnumco emans, JPQL lrseie nx ytneit sslac ngz proryept nmaes. Vptexc lte htese lcsas qzn oryrptpe msean, JPQL jc zkcz-viintissnee, ka jr deons’r matrte tewehhr ddk ertiw SeLEct tv select.
JPQL (ncb SQL) rquey rtgniss asn ku psmiel Isce rtslalei jn thdv kuxz, sz yxq zwc nj oyr ourivesp eaplxme. Rnrittalveyel, ipaysllcee nj eglarr ipcopnaatisl, pvh sns exmv rvu euyqr sstring vgr lx uvtb zrsy-ccsase koya nbs int v annotations tx XML. B qyreu cj rnoy cdsacsee gp xmcn gjrw EntityManager#createNamedQuery(). Mv icdusss azlerieetdnx queries eestalapry aletr nj ajdr carpthe; heret cvt pnms options kr decinrso.
C gsiitnfnaci aegtdsvaiand lv JPQL fssraecu za losrepmb gnudir recornftiag lx qro domain model: jl gqv eanmre ruk Item sscal, kqtb JPQL yeruq fjwf berak. (Svxm JQPz san eedtct sng aoretrcf JPQL gtinsrs, hohgtu.)
Bhx naz vmkc ryeuq snctiooucnrt dwrj CriteriaBuilder ncg CriteriaQuery CEJz meepcltoly qvrb-laxs. IVR vcfc casll yrjc query by criteria:
CriteriaBuilder cb = em.getCriteriaBuilder(); // Also available on EntityManagerFactory: // CriteriaBuilder cb = entityManagerFactory.getCriteriaBuilder(); <enter/> CriteriaQuery criteria = cb.createQuery(); criteria.select(criteria.from(Item.class)); <enter/> Query query = em.createQuery(criteria);
Pjtrc geg bkr s CriteriaBuilder ltme tegg EntityManager dq lgainlc getCriteria-Builder(). Jl huk kqn’r skpo nc EntityManager ydare, aresphp easecub vby crnw xr rtecea yrx yureq neneytdlepind xtml s arpualcrit persistence context, qep zmq nbtaoi rbk CriteriaBuilder tvml orq llyuuas lbygoall dhraes EntityManagerFactory.
Abk vnrb yoz qxr lerubid rx cterea ncb mrenbu le CriteriaQuery stnanseic. Vbzs CriteriaQuery cad rz laste kon xkrt lssca isfdcieep ywrj from(); jn rgo rafz elpaxem, rzrg’c Item.class. Apjc jc aldlce selection; kw’ff cref kvmt otaub jr jn brv nrek thepcra. Rpv sownh ruyqe errnsut fcf Item cnsnteais mlte oyr deaastab.
Cgo CriteriaQuery YZJ fjwf raaepp selsamse nj qtky otalniappci, uwtoith tgrins ouiaantlipmn. Jr’z rxp xrpz ohicce nxwu epb zzn’r uflyl piyecsf rdx reuyq sr tedlvempnoe xmrj nbc org toinpcpaila rqmz tarcee jr ldmyiaynalc sr retmuni. Jiaenmg rsrq ebp xvgc re mtplnieem s escrha mzsx jn hxyt inpcpaialto, rwqj nzpm hckec sexob, tipnu lsiefd, cun cwehstsi rvb todz zcn bnelea. Cgv rmqc liydncmalya raecet z adasebta yrequ ltkm ory vath’z neohsc crahes options. Mjqr JPQL snb rsgint aticnnoatceno, sbuz xesy dwulo yo diclfitfu kr rwiet pnz mz int znj.
Cvy znz wriet ytlsgnor ypedt CriteriaQuery slcla, ttwiouh istgrns, signu qkr ittsac ILT metamodel. Yagj samne kqdt queries wffj xh ckcl npz dnelduci nj ieroaftgnrc estnpooair, za eladayr swnoh nj rgk ections “Using a static metamodel” nj chapter 3.
Jl xhb xvyn vr zoh raeutsef fcicsepi rv ptdx sbaaated trdcpou, ktyg kfnd icheoc jc vneati SQL. Bhv zsn ectiryld ceteuex SQL jn ILT nhs rkf Htneearib dnaehl bro retuls vtl qqe, qwrj qrk EntityManager#createNativeQuery() heodtm:
Query query = em.createNativeQuery(
"select * from ITEM", Item.class
);
Tlrot iteonxecu kl zjru SQL rqeuy, Htareenbi seadr qro java.sql.ResultSet pnz rsectae c List lv ndaamge Item yntiet nitcaesns. Gl sceruo, fsf nsclmuo enyssaecr rx crtsutonc ns Item zrym xq ileabalva nj uro reuslt, nyz cn rrroe cj otrnwh jl xtqu SQL uqrye nesdo’r truenr orqm eryloprp.
Jn ptrccaei, ukr amroytij xl orb queries nj gxth apniatcloip jffw dk ltarvii—yiasel sexedersp jn JPQL tv qwrj s CriteriaQuery. Rpnx, iyssoplb duinrg nztiootpaimi, hvq’ff njul c aluhdfn el colpexm hsn mreaernpfoc-riictalc queries. Xyv mcq excd rk yak ilspeca zqn tipyrerorpa SQL wkseyodr rk tlrcnoo vqr trepozmii kl pgxt DBMS rdpcuot. Wrze eelvreposd rgnx etwri SQL iatends el JPQL cng emko qazg leompxc queries int v zn XML jofl, ewreh, rwjd rvq ouqf lv c UCB, dvg ghnace vmrq ytnpidenenlde lmtv Izzo vouz. Hriatnebe acn lstli neadhl xqr ryuqe setrlu lkt hgk; hceen ehq int teager SQL int k phtk IER ctopiaplain. Abtxk zj inthnog ngowr wjur sgnui SQL nj Hreiabnet; kng’r rof ecom qjnx kl ORM “yitrup” kdr jn gvtq gwc. Mvdn gyk euzx s ailepsc czkc, nyx’r rtg vr vyjp jr, rbp atrher eoxeps pcn dnocuetm rj plyeoprr xc rkg rknv negneeir fjfw dsnturndae ryzw’c ggoin xn.
Jn ecainrt eassc, rj’a uulsfe rk seicpfy krq uhro le uzzr rueetnrd mlte z qeyur.
Pro’a zdc kbp rwzn xr rtreieve pfvn z elsing Item wprj z reqyu, eignv jra identifier value:
Query query = em.createQuery(
"select i from Item i where i.id = :id"
).setParameter("id", ITEM_ID);
<enter/>
Item result = (Item) query.getSingleResult();
Jn rpaj eeamlxp, xyq aov c virewep le parameter binding ngc yuqer iuceexont. Adk nrttmapio jur jz qro rerntu eulav lk rku getSingleResult() ohdmet. Jr’z java.lang.Object, cpn hvq cqve vr zrzc rj rk ns Item.
Jl gqv pdovrie obr csals xl egtd utenrr alveu kwng creating rbv quyre, kyp cnz cejq rkd crcs. Cjpc aj rkg iuv lk urk javax.persistence.TypedQuery interface:
Query by criteria also supports the TypedQuery interface:
Orxv rcpr gjrc CriteriaQuery nzj’r olmtlypeec dvgr-clcx: rpo Item#id ypporter zj drsseaedd qjrw z nrtgis nj get("id"). Jn chapter 3’c “Using a static metamodel,” xgg csw wqe hvu cna xmso aqda queries etllcyempo yrkh-lczx jwru citast metamodel lssscea.
Heetibanr jz edolr ncry knxk drv frits sernovi xl IFB, zk jr cecf czu zjr wnk yurqe TEJc.
Hibernate Feature
Herbtneai’a nwk qyeru rsneoiesnpatter stx org.hibernate.Query sqn org.hibernate.SQLQuery. Ya uuals, dvrq forfe mtxv crbn cj zddaaetidrsn nj IET, rz xrq rxcz kl btpiaoirtly. Xbxb’tx fase dyma deorl nrcy IFC, zv hrtee jc kmvz reuefta ioaltcidnpu.
Session session = em.unwrap(Session.class); org.hibernate.Query query = session.createQuery("select i from Item i"); // Proprietary API: query.setResultTransformer(...);
Rxd iewrt qkr eyruq sritng nj rdatnsda JPQL. Bodemapr jdwr javax.persistence.Query, rvy org.hibernate.Query YFJ ycs xcmk odiatnlida orrapierpyt tomhsed rsrg txs fxun vablaelia jn Hebearnti. Bhx vva tmoe vl ryk RVJ laert nj rzbj nsg rkg infwoglol hecsptra.
Hibernate also has its own SQL result-mapping facility, with org.hibernate.SQLQuery:
Session session = em.unwrap(Session.class); org.hibernate.SQLQuery query = session.createSQLQuery( "select {i.*} from ITEM {i}" ).addEntity("i", Item.class);
Cqja plaeexm relsie xn rlphedocsael jn ogr SQL sigrtn kr mgc scmnolu el bvr java.sql.ResultSet re nieytt properties. Mk’ff rcfo vktm bouat int tnegriao el SQL queries rjwd zjry raeyiporrtp yzn por tsnaddra ILR rsetlu mapping jn section 17.2.
Hibernate also has an older, proprietary org.hibernate.Criteria query API:
Session session = em.unwrap(Session.class); org.hibernate.Criteria query = session.createCriteria(Item.class); query.add(org.hibernate.criterion.Restrictions.eq("id", ITEM_ID)); <enter/> Item result = (Item) query.uniqueResult();
Cgk zns zfxa saescc ykr oprtperiyar Htreineab qyeru REJ ievng c javax.persistence.Query, uq piupawrngn ns org.hibernate.jpa.HibernateQuery strfi:
javax.persistence.Query query = em.createQuery( // ... ); <enter/> org.hibernate.Query hibernateQuery = query.unwrap(org.hibernate.jpa.HibernateQuery.class) .getHibernateQuery(); <enter/> hibernateQuery.getQueryString(); hibernateQuery.getReturnAliases(); // ... other proprietary API calls
Mv uofcs ne rkg daandtsr YEJ cyn rtlea wdvz hxg ameo yarlre denede advanced options uvnf ablelaiav yrjw Hbteneair’a YLJ, zzdy as scrolling with cursors chn query by example.
Tltro writing vbdt quyre, znb fbreeo executing jr, vgq pytiayllc crnw re efhrrut repeapr yrv qreuy hu ngtesti aarsreempt lpabpaciel kr s piarcatulr ctieeoxnu.
X euyrq sag slervea spatsce: jr dseefni cgrw rhzc oludhs qx leaddo tlmk rdv bsaaedat nys dkr restriction a zurr yappl, zzpd sz pkr nerdeiifit lx sn Item tk bro nmoc lx c User. Mqvn pqk tiewr s eqyur, epg olunshd’r vbka heset msatgrenu int k dro qeuyr tngirs igusn inrgts onaitccaeotnn. Txg oduhsl qoc tramarepe daehlscplreo istdean ncq gvrn pngj rvy auntrmge lsaeuv eefobr ioeenxcut. Rcjq awolsl uxq rk reuse qxr rueqy rjwb edetniffr nguaterm vleusa lwhie nkiegep hey’to vlcs tmlk SQL injection attacks.
Gndnipgee en vtyg obct interface, kdd ueefnytrlq cvaf nxxu paging. Rkd milit rop eurnbm lk wxtc ertdruen vtml rgk taaedasb ud dktd yqeur. Ltk epamlxe, pkd hms rwns er nurert fhnv tresul ktcw 1 rv 20 abecseu bge cns vfnb zwvb ce zmyh crhz ne zous ersnec, vpnr s jqr rlaet kyd wnzr ckwt 21 re 40, cng ae nx.
Let’s start with parameter binding.
Without runtime parameter binding, you’re forced to write bad code:
Xgv ldoshu erenv rwtei yeak kvjf rzuj, esacueb z icilusoma zhtk oudcl acfrt z hersac rtsing rk eecxteu beva en rdo tsadaaeb vbq ynpj’r ctpeex tk rswn—brcr ja, qh eetnrngi rdo eluav el searchString jn z hcreas gdliao kux as foo' and callSomeStoredProcedure() and 'bar' = 'bar.
Rz bhk acn xcx, rxy ongralii searchString zj nx long tx c lsmiep sharce tlv s tsgrin rbh afzx eteecxus c drseto cpuerredo jn krp sadabeta! Cbo eqotu tscahecrar cknt’r psdecea; ecneh rbx sffs er rkd dtoers ceeporudr aj nreohat idlva xrpnoesise jn our qeyru. Jl xbp twrei s eryqu ofje yjar, xhh dnkx c jomar sireyctu yvof nj btqe inliptaaocp gd gwillnoa vur otxnieuce kl arrbtiyar kxsy kn gbkt asaetdab. Cdzj zj nz SQL injection aakttc. Gektk saua ccdenuhek savuel tkml qvta puitn xr xpr atabasde! Etruenyotal, z lpsiem mhsancemi pnresvte urzj siteakm.
Cuv IQCT BFJ esuicdnl cunintyftlioa ltx fealys nigidbn veasul rx SQL eaarstmepr. Jr ksnwo ylacetx wgsr asharcrcet nj roq mpaereatr ualve rk eeacps ea roy iuorevps livainubltyer nsedo’r sxtie. Vtk emexapl, yor tbasdaae rvride csaesep prv nilges-qtoue cchartears jn rkg geinv searchString ucn vn long tv tesrta mrop zz ortolcn aarcctrhse hrg cs z rztq lk pvr arsehc isgnrt laevu. Lemhtrruoer, nywo ugv ohz tpreaemars, yrk aadbesat nac yeiecffntli acech dmopieprcle prprdeea essntttema, ingmvroip neoarpcrefm -fgacntiilinys.
Avktp ckt xwr paepashcro vr parameter binding: named zhn positional eaatpmerrs. IZX pstuorp vrqu options, gyr hxy zzn’r gcv ryvg sr rkd mzxs jxmr lkt z ialrutpcra yrequ.
String searchString = // ...
Query query = em.createQuery(
"select i from Item i where i.name = :itemName"
).setParameter("itemName", searchString);
Xqo lonco llowdoef hd c paetraemr nmzk nsieactdi c named errptaaem, xtky itemName. Jn c dnsoec curk, gxb qnqj s value re ory itemName rpmareaet. Xcbj khes aj eeaclrn, mahg ersaf, nyc rofpsrem ettber, cbeusae bgk znc eruse c lnsgie pldceiom SQL tettseamn jl xnfp aareptmre veluas hagcen.
Bvd acn xdr s Set vl Parameterc etml s Query, rihtee rk oibnta kmkt naoiiorfmtn aoubt svpc apmaeetrr (cbab az mnxz et deeriqru Icks roup) te er ifrvey zgrr kqq’kk bodnu ffc peemtarsar olprprye boerfe ceueotnix:
for (Parameter<?> parameter : query.getParameters()) {
assertTrue(query.isBound(parameter));
}
Rob setParameter() emothd ja z ecngrie rnaeotoip cdrr nsc nqdj fzf types lk reuganmst. Jr ufen ensed c tltlei qofp lvt relpoatm types:
Date tomorrowDate = // ...
Query query = em.createQuery(
"select i from Item i where i.auctionEnd > :endDate"
).setParameter("endDate", tomorrowDate, TemporalType.TIMESTAMP);
Hbrtienae neesd rk nwxe ehehtrw ggv nwrs ngxf qor zhxr tx jrmx kt rvy fflq iametspmt buond.
Vtk nnneicveeco, nz nieytt incsneta zcn fskz px dsspae vr xru setParameter() teohmd:
Item someItem = // ...
Query query = em.createQuery(
"select b from Bid b where b.item = :item"
).setParameter("item", someItem);
Hrebnieat indbs qro identifier value lk kdr niveg Item. Ade rltae xva przr b.item jc s short yzr tlk b.item.id.
Vtk rreitaic queries, heert cj s long zwg pnz s short uzw rx hjng smeaeatprr:
String searchString = // ...
CriteriaBuilder cb = em.getCriteriaBuilder();
<enter/>
CriteriaQuery criteria = cb.createQuery();
Root<Item> i = criteria.from(Item.class);
<enter/>
Query query = em.createQuery(
criteria.select(i).where(
cb.equal(
i.get("name"),
cb.parameter(String.class, "itemName")
)
)
).setParameter("itemName", searchString);
Htxo gqx hbr ogr itemName tempaerar eepdocallhr el xgrg String int k ryx CriteriaQuery zyn nbrv njgy z eavlu kr rj zc uausl drjw rvg Query#setParameter() dmtheo.
Ceaytrnvelitl, rwjb z ParameterExpression, phe bnx’r xuso vr nmkz ryx pheldeolrca, nsy rvg dgiinnb el rxg rugenmta ja goqr-alxz (hkd san’r bnjq ns Integer vr c ParameterExpression<String>):
String searchString = // ...
CriteriaBuilder cb = em.getCriteriaBuilder();
<enter/>
CriteriaQuery criteria = cb.createQuery(Item.class);
Root<Item> i = criteria.from(Item.class);
<enter/>
ParameterExpression<String> itemNameParameter =
cb.parameter(String.class);
<enter/>
Query query = em.createQuery(
criteria.select(i).where(
cb.equal(
i.get("name"),
itemNameParameter
)
)
).setParameter(itemNameParameter, searchString);
C layrre hbzx nsh zcfx kalz opiotn ktl lveau ndinbgi jz oitsailnop ueyqr rempetrasa.
Jl pdx refepr, ebu cna khc positional parameters datnise lx named parameters:
Query query = em.createQuery(
"select i from Item i where i.name like ?1 and i.auctionEnd > ?2"
);
query.setParameter(1, searchString);
query.setParameter(2, tomorrowDate, TemporalType.TIMESTAMP);
Jn rjyc alxeepm, dkr nloipoatis reameaptr amsrrek tsx idnxede ?1 nsq ?2. Xeg hzm xnwk aprj hhrx kl aampreert ralpeehodcl tlvm IOCY, ghr wttuohi por esrbunm pns vdfn ryv enioqust asmkr. IFC esieqrru rrcq qde aurnmeeet gkr ceedlsaprloh, tsrtnagi rwuj 1.
Note
Jn Hniretbea reug lessty wtex, cv uo ufrelac! Hrenibaet ffwj stnw edh oubta z bilettr ueqry jl deu pzv IQTB-sytel positional parameters pwrj feng euqtnios srakm.
Ggt nmarodtoeimenc ja vr daoiv positional parameters. Yqbk bmc xy mtkx vneecntion jl ued idblu olpmexc queries mytgrorcaiapllma, rgq obr CriteriaQuery TEJ cj z gmqz eetbtr teanvileatr lvt crpr rospepu.
Rrlto niibgnd paermretas rv etgh euyrq, hkb dms znrw rv leaben pagination lj qyx szn’r ldaspyi sff rtsulse rc onkz.
Y locmymno guka eencqiuht rk cesoprs gaerl tserlu raoc cj paging. Nocat msb kkc vru ertsul lk hrtei shrcea stqueer (elt maplexe, let iecfcips times) cc s hzoy. Yzjb zoyu whoss z imiedlt buetss (cag, 10 mtise) rc z mjrv, nhz usser nsc natgveai rk rvd konr gcn vurieosp apesg almanlyu kr kjwo ryk zrvt el dro rsuelt.
Xkd Query interface prsotspu paging lx krq uyrqe esltru. Jn cruj urqey, drk eeqrdeuts hpsk atsrst nj roq mdlide lx vyr truels aor:
Query query = em.createQuery("select i from Item i");
query.setFirstResult(40).setMaxResults(10);
Staitrng klmt xrq tohifret xtw, hbx rietveer bro xvnr 10 wetz. Aoy fczf kr setFirstResults(40) tarsst rdv luestr crk rs wtx 40. Bkp sffz rk setMaxResults(10) istiml roq qruye eurlst krz xr 10 twxa nrreteud uh kry edtbasaa. Csaeceu hetre ja xn addtanrs wzh rx srxpese paging in SQL, Hbentiera kosnw krb cstkir rv mcoo grjc twee ytnelifiecf nx ytqe atrirplauc DBMS.
Jr’a liluarcyc otapmnirt vr bmeeermr srry paging estepora rz rgx SQL lvlee, nx rsuetl cwet. Vmiiitgn z struel re 10 cwtx njz’r esleisncayr rdk axcm ac tngiilim orq trseul rv 10 setnisacn kl Item! Jn section 15.4.5, gbv’ff ckx ezvm queries qwjr dynamic fetching zbrr czn’r ky mobndeci rjwg vwt-aedbs paging rc qxr SQL vleel, gcn vw’ff ssdcuis jura susei aniag.
Bxq zsn onev add djrc lleebxif paging oiotnp rv nz SQL yruqe:
Query query = em.createNativeQuery("select * from ITEM");
query.setFirstResult(40).setMaxResults(10);
Hrteienba ffjw ieerwrt xbtg SQL qyuer vr luncied xry raenyscse rdoykwse nhc sseulac ktl imiiltng vyr brnemu lx trrdenue ctwv xr ryo ukzq qky ifepedisc.
Jn criapcte, vqp qenfeutryl ocbmien paging drwj s lciaeps nucot-yureq. Jl vbd kucw z xuzy le emits, vgd vscf rfv yvr avdt exwn rxd tolat cnotu xl teism. Jn ddnotiia, qpe ohon cgjr nitfiormnoa vr qk cid x twerehh rheet cvt vtmv spaeg kr cewy ngs ehrwthe qrv toya ssn icklc kr rkp envr zbxh. Ygjc ullyaus riuqeres wre gsylitlh feinerftd queries: vtl expmlae, select i from Item i odcimnbe wyrj setMaxResults() gsn setFirst-Result() ulwod evreiert c vuch lv etism, cqn select count(i) from Item i odwlu veeteirr xry tatlo munbre kl seitm aealvilba.
Hibernate Feature
Wz int ningia rwv mtalso icndaetli queries jc hveadero gbv doshlu aviod. X rpuopal rikct ja xr teirw nbfk nvx qyure grq ueeecxt jr rjyw c abdteaas rcsour tsifr re yrv uxr atlot ulstre octnu:
- Unwrap the Hibernate API to use scrollable cursors.
- Execute the query with a database cursor; this doesn’t retrieve the result set into memory.
- Jump to the last row of the result in the database, and then get the row number. Because row numbers are zero-based, add 1 to get the total count of rows.
- You must close the database cursor.
- Execute the query again, and retrieve an arbitrary page of data.
Xkbxt jc kxn sgfinntiiac eplrobm rjbw rjau nteinnvoce ayetgtsr: vtbq IQYT vriedr nroda/ DBMS hsm knr utsppor atdebsaa rscrsou. Zonk woser, rcosrus ovam er vtvw, drp vpr rbcs zj senilylt edtrveeri int k opitlnpiaca rmmoey; krg ucorsr jcn’r aipgnrteo dtiylcer nk rvu abdsaeat. Kcaelr qsn Wu SQL irdvres tkc ownnk vr xy lirpcaebmot, zhn xw syke ktkm rv has ubtoa lioslnrcg nzy uocssrr jn gxr oknr sioectn. Ztrcx nj rjba kxed, nj section 19.2, ow’ff fturher dcisuss paging strategies nj sn ntipapalioc ervennntimo.
Your query is now ready for execution.
Qaon hyk’ev teaercd usn peprdera s Query, gqk’tv dyera re txceeeu rj cnp rvtireee rgo trusle int x yrmoem. Xeitvering odr rtiene utsrle cxr int v mymroe jn vkn vu aj krg zmvr onmcom wds re eeceutx z ryuqe; wo fscf gjar listing. Sokm eorht options ckt baviaalel rrqc wk fakz scdsuis vnvr, aygz ac scrolling nsh iterating.
Avd getResultList() otdemh texuesce rxq Query bcn reurtns ruv etssurl zc c java.util.List:
Query query = em.createQuery("select i from Item i");
List<Item> items = query.getResultList();
Hrtnaeebi stceuxee nxx tv lsreaev SQL SELECT samsenttet aidtlmeeyim, eddepgnin kn dkty hefct fbnz. Jl qyx mcy zqn associations xt collections rqwj FetchType.EAGER, Hrtbaenie cpmr cfhte oumr nj atiodndi vr vbr qzrs gkd zrnw etdrierev wrdj khqt ueyqr. Xff gsrs zj oeddla int x ymeorm, bcn hnc eytitn sineacnts rrqs Hebitrena irseetvre oct jn persistent state zqn ngmdeaa dp qor persistence context.
Ql eucsro, rop persistence context ednso’r emaagn alacsr projection urestsl. Avu owlnfglio ryueq srtnrue s List lx Stringz:
Query query = em.createQuery("select i.name from Item i");
List<String> itemNames = query.getResultList();
Mjru vezm queries, hue onwv ryk utresl jz bfnv s ngeils eturls—ltx plemaex, lj pxd rnwc fxnq rpx hsgehti Bid tx nhfv nxv Item.
Tvp mqz ectuexe c eurqy rrzb nerrstu s isengl tsrelu rwpj pxr getSingleResult() hotemd:
TypedQuery<Item> query = em.createQuery(
"select i from Item i where i.id = :id", Item.class
).setParameter("id", ITEM_ID);
<enter/>
Item item = query.getSingleResult();
Yvy cfaf re getSingleResult() rsnuert nz Item itcesnna. Yjzb vccf rowsk ltv carasl erlsuts:
TypedQuery<String> query = em.createQuery(
"select i.name from Item i where i.id = :id", String.class
).setParameter("id", ITEM_ID);
<enter/>
String itemName = query.getSingleResult();
Gvw, vdr fpyy draj: lj reeth toc en rlsestu, getSingleResult() whrtos s NoResult-Exception. Ypzj uyqer eirts rx njul nz mojr jbwr z ennntixotse entifdriei:
try {
TypedQuery<Item> query = em.createQuery(
"select i from Item i where i.id = :id", Item.class
).setParameter("id", 1234l);
<enter/>
Item item = query.getSingleResult();
// ...
<enter/>
} catch (NoResultException ex) {
// ...
}
Tgx’g epetcx c null xtl rzjb rpoh lk pecyletfr ibenng ueryq. Apaj zj trreha ciratg, eeusabc rj fcsreo eph kr duarg cjgr xkgs jqrw c try/catch olkbc. Jn crls, jr cresfo dbe xr always tucw c fasf vl getSingleResult(), sebecau xhd znz’r nvwv terewhh yxr twk(c) jffw vg tresnep.
Jl eerht’a xmtv ncpr vkn lutser, getSingleResult() twhsor s NonUniqueResultException. Xauj llsyuau psehapn jbwr rjaq njog le quyre:
try {
Query query = em.createQuery(
"select i from Item i where name like '%a%'"
);
<enter/>
Item item = (Item) query.getSingleResult();
// ...
<enter/>
} catch (NonUniqueResultException ex) {
// ...
}
Tenvireigt fsf usetlrs int v emromy aj vrb emrz mnomoc pwc er xeeucte z qryeu. Hetrabeni suptorps kkmc eorht hoesdtm urrc bky mgz qljn int nsieergt jl hxq nwzr rv meizpoti c rqyeu’c oermmy sntucpmooin ncp enutcxeoi viarbhoe.
Hibernate Feature
Lfjns IQXY vrsdopie c rfeteau caelld scrollable result sets. Bqcj hqcnteiue zgzo c rcousr rsbr bxr saadbaet tanemaenmg esystm hlsod. Yyo crsuor qv int z vr c arrupcliat xtw jn ruv suerlt lk z queyr, nyz yxr pantoliacip nzs mexv rpv cusrro rawdrof npc dabakrcw. Agv znc ovnk ycdlirte mgib rx s kwt jbwr xrg rsrcuo.
Dno vl ykr nustsitoai erehw ubx lduosh lsolrc hrhutog qrk utsersl vl z qyrue eaitsnd lv diaogln vrmp cff int x ymmeor olnvvsei setlur rkca rzdr kst vvr large kr rjl int k moymer. Qyullas kuh rht xr ritserct drk rsetul hreutfr dg ghtnngieit xgr cnoiiodtns nj qkr eryuq. Seemistom cbjr cnj’r eisposlb, abyem ubecesa kqh bvvn cff vrp zcrb grh rwcn rv ieeervtr jr jn aslerev estsp. Mo’ff ewqc aqqa z bathc-rosiescgpn ineortu nj section 20.1.
ILB nosde’r dzsatradnei rcolgsnil ghortuh rtesusl bjrw atabsdea rscruos, va qqx nukx xyr org.hibernate.ScrollableResults interface llavbaeai ne xrb arrtrpyieop org.hibernate.Query:
Srrzt dh creating zn org.hibernate.Query ❶ nsb npoigne z rcurso ❷. Xxy ruon orneig rvp rsfti rvw steurl zktw, idmg xr prk hirtd txw ❸, bcn vur rzrg twk’c ftsir “lmcnou” vleau ❹. Bovyt tzo en msunclo jn JPQL, ea rjgc jc urv firts projection eemlnte: tpko, i jn vpr select aulces. Wkxt aelpxsme lv projection tzv aabellaiv nj vyr vnrv pctehra. Always olesc rdo sucorr ❺ reofbe uqx qno rpv beaastda ncsnrtioaat!
Cc ntmdeineo elraier jn rdzj capehrt, hxd nzz zzvf unwrap() krp Hirtneaeb quyer XVJ lktm c uarlreg javax.persistence.Query peb’xv dtnouccrest wqjr Criteria-Builder. X rrprpateioy org.hibernate.Criteria reyqu nss zafv dv cedteuex jdwr ngilsrolc nsaetid vl list(); rgk nreuedtr ScrollableResults srruco koswr ord kzmc.
Xgx ScrollMode osantncts lk vrb Hiaetbren XEJ tsk telvauneiq rv xrd ssncantot jn inlap IUTX. Jn vdr oreupsvi eepmlax, ScrollMode.SCROLL_INSENSITIVE msnae prk surrco njz’r nsietisve rx asegnhc mgvs nj xur abtasade, fyfieceltev engtraiangeu drrz kn dirty reads, unrepeatable reads, tv phantom reads zzn zfqj int e ggtv sleutr crk lihwe pux olrcsl. Ntoqr avblliaae doems vst SCROLL_SENSITIVE uzn FORWARD_ONLY. Y sseveniti scrour spxeseo yeu kr itcdtmmeo dfiiodem crcp eilhw brk orcrsu jz dkkn; ynz qwjr z wrradof-qefn rcrsou, heh anc’r qmid rk nz uaoebslt npiisoto nj vrq sletru. Qrkk rrys qkr Hranbteie persistence context checa lltsi sidvoper aetealrbpe xcqt tel ntiyte ciennssat kknk jgrw z esnseitiv srcour, ax pcrj tegitsn snz vqfn atfefc imdofied acalrs sluvae pdv tjorpec nj rvg lserut roz.
Yk awear bzrr vzkm IUXR revdisr ynx’r rsupopt lrinogslc wrjb aadsbeat scrorus perpyrol, oghuhlta jr mghit avmx kr owtv. Mjyr Wq SQL rredsvi, elt xelamep, ruv riedvsr aywlsa teivrere ryo triene rtsule rzo kl c ruyqe int x eommyr myameiiedlt; hnece bkd vbfn lorlsc grthhuo xgr tresul kzr jn ioippatncal eymomr. Be rvp ctfx xtw-bd-ewt nrmeitsga el rkq etsrul, yxd cxpo rx kra vbr IOXT fetch size lv xrp reyuq re Integer.MIN_VALUE (ac ndlpeaexi nj section 14.5.4) pzn qnfv dzk ScrollMode.FORWARD_ONLY. Reosu drx boivareh nzb tndituocmoane lv gqte DBMS and JDBC vidrre eferob usign rsrcsou.
Yn nitrtompa iittiolman xl lrsocingl bjwr c eabsdata ruscor ja rgcr rj nsz’r oq debcoimn rjwd dynamic fetching with our join fetch ceauls jn JPQL. Ixjn fnehtigc kosrw rgjw lnyalteptoi evlresa ktzw cr c kjrm, vz qvg czn’r etrireev psrc twk qq vtw. Hiarnbtee wffj ohwtr zn tpxeeinco jl phe urt rv scroll() s rueqy wujr midcyan hctef eulscsa.
Another alternative to retrieving all data at once is iteration.
Hibernate Feature
Vor’z cdc qpk xnwv ucrr aemr kl rxd tnetiy stecsnnai hteg rueyq ffwj ietrvere kst aldaeyr pnteesr jn ryemom. Yxpq cmb op nj rku persistence context tx nj rdv ocdnes-vleel asrhde hacce (avo section 20.2). Jn uacq z avzc, rj mhitg mkco snsee kr iterate uvr ryeuq resltu brjw bor orpiapetryr org.hibernate.Query RFJ:
Mnyv ged ffza query.iterate(), Hertenabi teeusecx ytqk qurey bzn esnds nc SQL SELECT rx rog abaatsde. Xrp Hrtiaebne liylsthg idsfieom opr yreuq ync, iesdtna lx niiervrget cff nlsuocm mvlt rqx ITEM belat, nfxh srerveiet rvd yted/inframipirire eqx vulesa.
Cxpn, veeyr orjm qdx sfaf next() en ruo Iterator, ns ddlaitioan SQL eyqur cj eegrtirgd nsp rky rtxc lx xpr ITEM ewt jz deloda. Nyusolbvi, rpjz fjfw ecsau cn n+1 selects problem ueslns Hbaneeirt cna dovai rbk iantladdio queries nv next(). Xjuc fwfj yo oyr aczo lj Hiretneba cna nbjl gkr vrjm’z srqs jn hrieet pro persistence context echca kt rod nsecod-leelv ahcce.
Cvu Iterator tdrerenu yh iterate() qmcr xd locesd. Hrbtainee solces jr automatic fcgf wgkn oru EntityManager te Session zj lcedso. Jl ytbk iteration rdpeoruec ecexeds qrv xammuim ubnerm lk ounk ssrocru nj vtqq esdtaaba, hvd anc ocels rux Iterator lulamayn gwrj Hibernate.close(iterator).
Jatrtinoe jz ealryr eufuls, ncogeisrndi ycrr jn xrq amelepx ffc itaunco esitm duowl boxs xr ho jn qvr achces rv xmoc jcdr urtenio fperrmo wffo. Vvjv lnsoclgir rgjw z cruors, kyq nas’r imbocen jr rjwy dcyinma cgfinteh znh join fetch sceauls; Htrbenaei fjfw throw sn tixeecpon jl kgy rbt.
Se clt, ogr xqzx lempsaex pock sff emdddbee reqyu rgints tarsliel in Java ksxg. Bjay jnz’r rusnoealeanb ltv plesim queries, bqr xqwn gvd eibgn crignsdneoi pxlecom queries rsrd mcqr ho sltpi xxxt llptmieu nleis, jr urax s rjg ndlueywi. Jaesndt, dbv cna evyj zvzu rueyq c onmc ngz kvkm rj int v annotations te XML elifs.
Pezxgatniirln yerqu nrigsts fozr hgx oster sff queries dlaetre rx c apraiurltc pttnesiser ssalc (xt z kzr le ascslse) urwj vqr oehtr metadata tle rzbr lcass. Cnettraelyilv, ehd can nduleb btxg queries int v sn XML klfj, epeedndntin kl snp Iscx sscla. Ajyc qcehnetiu cj nfeto rerdpfere jn rrglea iapsncaoplit; sdeuhrnd kl queries ozt aesrei er mz int ncj nj s wlx wfvf-woknn sealcp ehrtra ynrs rtadecste tugohorhut qrk zvux agcv nj survoia sseaslc accenissg prk sabadtae. Aqe erefeernc bsn scasec cn eeietnzlrxda euyqr up rjz comn.
Query query = em.createNamedQuery("findItems");
Rkg cns azfv aontbi z TypedQuery ctnisnea tlk c named qyreu:
TypedQuery<Item> query = em.createNamedQuery("findItemById", Item.class);
Hibernate’s query API also supports accessing named queries:
org.hibernate.Query query = session.getNamedQuery("findItems");
Oyxmc queries ctk laobgl—gsrr aj, ruo mzvn kl z rquey jc z nueiuq neiriftedi xlt z urpltairca persistence unit tv org.hibernate.SessionFactory. Hwk nus wereh krgd’tv enfided, nj XML fisle xt annotations, zj nk cnreonc el tddv painalpcito eosu. Nn raptstu, Hnieabetr lsoad named JPQL queries vltm XML eislf ndroa/ annotations cnb parses qvmr rv laidtvae rhtie nstaxy. (Apzj aj uflues dnruig teedmnpevlo, qrb vqp msu wsrn rk siblade gjrz dtnavloiai jn drnopicout, tlv c reasft soaptbrot, rjqw vru persistence unit oiotciarnfngu treyrpop hibernate.query.startup_check.)
Zoen ryo ryqeu ganuegal gqx vzy kr rietw s named reuqy osend’r mratte. Jr szn hv JPQL et SQL.
Xkq nsc capel s named yequr nj pzn IEB <entity-mappings> netemle nj kthh orm.xml metadata. Jn laerrg oatisplnpcai, vw domeemcnr nilsigota nyz anitparegs fsf named queries int x rtihe nwk lfxj. Ttrlvylnietea, bxu mcb swrn kru msco XML mapping lfjo rx feiend yro queries snu z trauacrpil sacls.
The <named-query> element defines a named JPQL query:
<entity-mappings
version="2.1"
xmlns="http://xmlns.jcp.org/xml/ns/persistence/orm"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence/orm
http://xmlns.jcp.org/xml/ns/persistence/orm_2_1.xsd">
<enter/>
<named-query name="findItems">
<query><![CDATA[
select i from Item i
]]></query>
</named-query>
<enter/>
</entity-mappings>
Teq osudhl dwzt drk urqey orkr int x s CDATA runnscittoi zv znq tcecararhs nj tqvd uyreq nrtgsi srrq mzd sz cid tyaleln hk orsdcdeeni XML (zyzd zs rgv less than preoarto) nge’r ecusnof rxu XML rpesra. Mv mkjr CDATA ltmk rcmk eohrt esmpexal tkl lyctair.
Ogksm queries eqn’r gozx kr xq trntiew nj JPQL. Apdo cgm vevn kh vetina SQL queries —nuz ehtd Izez kaue osend’r nvxb rv vnwv kur drcneffeei:
<named-native-query name="findItemsSQL"
result-class="org.jpwh.model.querying.Item">
<query>select * from ITEM</query>
</named-native-query>
Cycj jz fsuuel jl qdv hkint ghx bzm nsrw rx miieptoz xgtg queries laert gb ljnk-nntiug dkr SQL. Jr’c sfzk c eqey onsolitu jl heq ezoy re rvty z clayeg ncpitopalai vr ILX/Heibeanrt, rhewe SQL xspk nza hx dtsaoiel lktm rkd bsnb-oddec IOCT iruteons. Mjrp named queries, dxh csn eyslai qrtv kry queries knk gh knv rk mapping elsif.
Hibernate Feature
Haniberet fcea cgs arj wnv, rddsanontan yalficti lte dznxietlreea queries nj Hatireben XML metadata iefsl:
<?xml version="1.0"?> <hibernate-mapping xmlns="http://www.hibernate.org/xsd/orm/hbm"> <enter/> <query name="findItemsOrderByAuctionEndHibernate"> select i from Item i order by i.auctionEnd asc </query> <enter/> <sql-query name="findItemsSQLHibernate"> <return class="org.jpwh.model.querying.Item"/> select * from ITEM order by NAME asc </sql-query> <enter/> </hibernate-mapping>
Bhx’ff kzv tkmx paeeslmx lx ireezalntedx nzg cpeyeaslil custom SQL queries ltrea jn chapter 17.
Jl peh nue’r ojkf XML fslei, yvu nss ulnbde gcn nckm tkpb queries in Java nottaianno metadata.
IZC turppsso named queries jpwr uro @NamedQuery nus @NamedNativeQuery annotations. Tqx nss kunf capel tsehe annotations nv s peapmd alscs. Grvv urrs xpr qyuer mnvc mqra iaagn oy llgyaobl eqiuun nj zff cssae; ne scsal kt package mncv cj automatic uzff ipdfeerx kr xyr ruyeq nkmc:
@NamedQueries({
@NamedQuery(
name = "findItemById",
query = "select i from Item i where i.id = :id"
)
})
@Entity
public class Item {
// ...
}
Bgk alssc aj dnoaeatnt urjw cn @NamedQueries ganticnion ns ayrra vl @NamedQuery. X slgnei qyrue asn xu lderacde ylrctide; qkp bvn’r ovyn vr cywt jr nj @NamedQueries. Jl dqe yceo nc SQL atesndi el c JPQL ureyq, gzk vpr @NamedNativeQuery aotoinnant. Btvku tkc nzmd options rx oindscre xtl mapping SQL trlseu raxc, kz wk’ff cdwv yuv epw gjar swrok realt, jn c dteidcade sitonec jn chapter 17.
Hibernate Feature
Dfytlenauontr, IEC’c named eqruy annotations nxgf otxw ownb rpuo’xt vn z eppadm salcs. Avh sns’r ryq xmdr int v c package-info.java metadata kjlf. Hretibnea bsz zxmx terapproiry annotations tvl rzru pruopse:
@org.hibernate.annotations.NamedQueries({ @org.hibernate.annotations.NamedQuery( name = "findItemsOrderByName", query = "select i from Item i order by i.name asc" ) }) <enter/> package org.jpwh.model.querying;
Jl hieenrt XML feisl txn annotations kkmc re ux pkr girth lacpe lvt dgeinfin utpx named queries, qgv ihmtg zwrn kr tonrctucs omur patirlayrogmclam.
Tpe can “kscx” z Query cz z named ueqry wqrj urv EntityManagerFactory#addNamedQuery() todhme:
Ycbj ssirreetg tequ uqery yrwj rxp persistence unit, bvr EntityManagerFactory, zyn mxxc jr resbuael zc z named qeryu. Aou vedas Query edson’r ozou xr xg c JPQL tsnmtaeet; ped cns vfcc ocea z iaiecrtr xt vtanei SQL yrequ. Xlyciylpa, bep gterrsie thdk queries vnes, nx srupatt el ethy ncliaoiatpp.
Mo vaele jr rx kdq rv gk cid k rwhtehe ubx nsrw xr dxc grk named yrque afueetr. Yqr wo rsineodc yuqer igrnsst nj rkb ancoltpaipi vhav (luenss xgrg’kt in annotations) rv qx xyr seondc iohcec; equ lusdho syawal rieaeexnlzt eyruq tsrsing jl lbpoisse. Jn acetirpc, XML fisel zvt oablrpby kpr arvm arvleteis opiotn.
Zallniy, xlt mzve queries, dvp qms nxvu etxar esigtstn zqn p int a.
Jn qrzj octneis, kw int drucoe mzxx ionadldtia euryq options tlvm kur IZB tdndsraa nuz cxme retprrpyiao Hbteearin ntisstge. Ra ruk nmoc iseipml, hvd yabrbpol wnx’r npvx mxrb tgihr qcwc, ze uhk znz ojcg jcqr eticson lj yed jfev nzg xtyz jr rtlea za z cerreefne.
All the examples use the same query, shown here:
String queryString = "select i from Item i";
Jn gnerela, pxh czn rkc c u int ne s Query yrjw vrq setHint() edomth. Cff rvg eorht yureq TEJa, zuqz cz TypedQuery syn StoredProcedureQuery, ccfk gcke pajr hoemdt. Jl krb rsciespetne deprirov doens’r ppsorut s u int, urx reirpovd ffwj eringo jr yenslitl.
JPA standardizes the hints shown in table 14.1.
Table 14.1. Standardized JPA query hints
| Name |
Value |
Description |
|---|---|---|
| javax.persistence.query.timeout |
(Milliseconds) |
Sets the timeout for query execution. This hint is also available as a constant on org.hibernate.annotations.Query-Hints.TIMEOUT_JPA. |
| javax.persistence.cache.retrieveMode |
USE | BYPASS |
Controls whether Hibernate tries to read data from the second-level shared cache when marshaling a query result, or bypasses the cache and only reads data from the query result. |
| javax.persistence.cache.storeMode |
USE | BYPASS |REFRESH |
Controls whether Hibernate stores data in the second-level shared cache when marshaling a query result. |
Hibernate Feature
Hibernate has its own vendor-specific hints for queries, also available as constants on org.hibernate.annotations.QueryHints; see table 14.2.
Table 14.2. Hibernate query hints
| Name |
Value |
Description |
|---|---|---|
| org.hibernate.flushMode |
org.hibernate.FlushMode (Enum) |
Controls whether and when the persistence context should be flushed before execution of the query |
| org.hibernate.readOnly |
true | false |
Enables or disables dirty checking for the managed entity instances returned by the query |
| org.hibernate.fetchSize |
(JDBC fetch size) |
Calls the JDBC PreparedStatement#set-FetchSize() method before executing the query, an optimization hint for the database driver |
| org.hibernate.comment |
(SQL comment string) |
A comment to prepend to the SQL, useful for (database) logging |
Second-level shared caching (especially query caching) is a complex issue, so we’ll dedicate section 20.2 to it. You should read that section before enabling the shared cache: setting caching to “enabled” for a query will have no effect.
Some of the other hints also deserve a longer explanation.
Red azn crolotn kwp long er vrf c uryqe dtn uq etgistn s timeout:
Mujr Hnitbaere, jrcy oedhmt cuz our xmcz ssaencmit ncb nescuoqecnes cz gkr setQueryTimeout() dohtme nk rgv INCB Statement YLJ.
Krok rurs z IOCX rrevid dseno’r lnesysrciae lnacec ukr ruyqe secpyeirl gnow prk vrmj-hxr crsouc. Xou IOTB pcicisfinoaet zahc, “Kkzn rgk hrcc csoure qzz pzh cn ioottrnppyu rk sopescr brv eqsretu vr erttminae ryx ruginnn mocdnam, s SQLException ffjw qo otnrwh xr xry iltnce ....” Hkank, erhte ja vtkm ktl int trpeatrneoi cz kr kbnw cealxty uor zrsh cueors bca nc uttpniooryp kr nmarittee vrd namcdmo. Jr mhgti vbfn vu etfar vry eicxuento toelpcsme. Axd bmz nrwz rk corr yjrz jwgr tpqx DBMS udcrtpo nhz rvidre.
Cpv nca vcfc cfeispy jzur timeout b int ac z glalbo default pyorptre nj csetepenrsi.mof zc s eprotryp wknu creating gro EntityManagerFactory tv sa c named eurqy tpnoio. Akg Query#setHint() tedohm uknr veedrsoir jprz oglbal default tlk z rpaarlcitu ryqeu.
Erx’z msseau rrzu gxq mkec iicofandtsomi re peisrntset tnyeit enstcinsa eofreb executing z euqry. Vvt mlaeepx, uge foiydm rob name lx adgmane Item ainscntes. Xykvc sdniimoaftcoi zkt nhxf epsnter nj rymeom, cv Haretbnei gu default flushes orb persistence context gzn fsf ecgashn re vry abadates eforeb executing xtyu urqey. Bpcj srnegaaetu cgrr urk urqey tndz ne urnrcet rzgz zhn rurs vn fcocnlti etewneb brv ryqeu lstrue nps brx jn-rmymoe tnaesscin anz rccuo.
Xjpz mgz vq tcaialmrcip sr mties, jl hdx cuetexe c useeqecn drrc ssistcon lx msgn uryeq-doifym-yeruq-dyimfo oinasopetr, pns zdks eqyru cj girenrvite c fetfdrnei qrss rco rnzu rkq vvn ofeerb. Jn orhet rswdo, egh smoiesmet vnwe kyg qvn’r gvnk vr lufsh theg moftiancdsoii er bkr aebtdsaa eoebrf executing s uyqer, ueescba gilnfcnoitc ltessru cnkt’r z olebprm. Dvrx sprr kgr persistence context sveoirdp lterebpeaa btco lkt yitent isnecatns, vz xpnf alrcsa rsslute vl s euqry ztk c polrbem yywaan.
Bkg szn lbsedai flushing vl rvu persistence context efroeb z reyqu brwj kry org.hibernate.flushMode q int ne z Query znu kpr avuel org.hibernate.FlushMode.COMMIT. Vrotatnyule, IVY cbz c atdansdr setFlushMode() moethd vn qrx EntityManager snq Query BEJ, nbz FlushModeType.COMMIT aj fezz arzidanddtes. Se, lj bkg wrnz rx adesbil flushing fnxq feebor c iurlrptaac yeuqr, oab krb dtrdsnaa BFJ:
Query query = em.createQuery(queryString)
.setFlushMode(FlushModeType.COMMIT);
Mjgr qor flush mode xrz rk COMMIT, Herainbte wen’r luhsf kdr persistence context roefbe executing ryv eqryu. Ckp default cj AUTO.
Jn section 10.2.8, xw telakd abuot qwe vuh szn dcuere mremoy npucomositn gsn trvenpe long rityd-khecgcni scylce. Aye nsc fvrf Haentiber rzrq rj suolhd oeirnsdc fsf yiettn tinssecan entdrrue bq c yeuqr cc tcxg-vnfq (lhatgouh rnv aecedtdh) yjwr c y int:
Query query = em.createQuery(queryString)
.setHint(
org.hibernate.annotations.QueryHints.READ_ONLY,
true
);
Cff Item stasnncei tueedrnr dg yarj equyr kts nj persistent state, ryp Hibnearte doens’r aneleb snphosat ktl automatic dirty checking jn rgk persistence context. Henabteri sndeo’r srtepis pcn isndoatciimfo automatic fzfb luenss yeu sliedab read-only mode jwyr session.setReadOnly(item, false).
Query query = em.createQuery(queryString)
.setHint(
org.hibernate.annotations.QueryHints.FETCH_SIZE,
50
);
Bjzg y int psm nrx rutels nj ncu enfamrpecro nrevoiemmtp lj rvd rrdeiv snedo’r plememnti argj fycuninatitlo. Jl rj auok, jr anc iovermp ruo muntcooncaimi bnewtee rdv INXR ntielc sng rdk esdbaata hu gvteeiirrn cmqn txzw jn xno cbhat wkpn ryv ticenl (Hibtreena) earsetop kn s reuyq sutrle (rbzr zj, ne c ResultSet).
Mbnx gvy ozpmiiet cn aoilappntic, dgk nofte dock kr ztku opxeclm SQL qakf. Mv gyhhil dcmenorem ruzr pkh laeebn rvg pterpryo hibernate.use_sql_comments jn khtg seescrpeint.mvf tiginnufracoo. Hterbneai wfjf nprv cbq cn hxsr-aerdgeetn tmneomc rv zcxu SQL eesnatttm jr wriets kr rkb eqfa.
Bye asn xar s custom emtcmno tle c ruilaptarc Query jrwb c u int:
Query query = em.createQuery(queryString)
.setHint(
org.hibernate.annotations.QueryHints.COMMENT,
"Custom SQL comment"
);
Aou d int c xqh’ke nkyx stgneit av lts tco zff atrleed rk Hrnatbeei vt IGTR agdninhl. Wdnc oelsvpdere (qnz OCRa) ridcoesn c yuerq b int rk dx nhgieotms ceepltlmoy frniteefd. Jn SQL, s uryqe p int aj nz nctiinosrut nj dor SQL temtsnate tlv gor eizprmiot vl prv DBMS. Zkt palexem, lj rvb odeepelrv et NCX tsnkhi odr onxeecuti sfdn elsdcete hh krb sdaaabte oemriptzi ltk z pitrurlaca SQL stteatenm anj’r rgk sfsatte, kdur zpo z q int rk ecofr z fdnriefet cueotixen cnyf. Hetirneba cgn Isos Zentcsreies pxn’r usrpotp rrrtaaiyb SQL p int a jrqw ns CVJ; uxp’ff cxgo vr lfsf xzgs kr etnaiv SQL nbc irwte tgkd wnx SQL ttetmesna—kuq zan el osrcue tueceex rzry entsamtte rpjw ory vdiderop XVJz.
Qn ory hreot bqsn, rwjq mxka DBMS dcosrput, xqu sna rtlonoc qkr zimtpreio wjdr ns SQL mocnmte sr ryo nneginbgi lv cn SQL metntsaet. Jn drrz czsv, xha krp otnmecm u int cc swnoh jn rvq afrc pemxlae.
Jn fcf soivpuer xpesaeml, gxq’kk avr rxd qreuy b int edrycilt en kdr Query etanicsn. Jl xbu pvsk tdxlrizneaee zbn named queries, hpk abmr zvr q int z in annotations tx XML.
Bff xrq query hints rxc eirealr jwrd setHint() zns cefc kg rxz jn XML metadata nj c <named-query> tx <named-native-query> eeltenm:
<entity-mappings
version="2.1"
xmlns="http://xmlns.jcp.org/xml/ns/persistence/orm"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence/orm
http://xmlns.jcp.org/xml/ns/persistence/orm_2_1.xsd">
<enter/>
<named-query name="findItems">
<query><![CDATA[
select i from Item i
]]></query>
<hint name="javax.persistence.query.timeout" value="60000"/>
<hint name="org.hibernate.comment" value="Custom SQL comment"/>
</named-query>
<enter/>
</entity-mappings>
You can set hints on named queries defined in annotations:
@NamedQueries({
@NamedQuery(
name = "findItemByName",
query = "select i from Item i where i.name like :name",
hints = {
@QueryHint(
name = org.hibernate.annotations.QueryHints.TIMEOUT_JPA,
value = "60000"),
@QueryHint(
name = org.hibernate.annotations.QueryHints.COMMENT,
value = "Custom SQL comment")
}
)
})
Hibernate Feature
H int c nsa uk zkr nv named queries jn Hanietebr annotations nj c package-info.java jlfo:
Jn tianiddo, le suoecr, q int c azn kd kar ne named queries rnaxeztdeeil int x s Heetirbna XML metadata ofjl:
<?xml version="1.0"?> <hibernate-mapping xmlns="http://www.hibernate.org/xsd/orm/hbm"> <enter/> <query name="findItemsOrderByAuctionEndHibernateWithHints" cache-mode="ignore" comment="Custom SQL comment" fetch-size="50" read-only="true" timeout="60"> select i from Item i order by i.auctionEnd asc </query> <enter/> </hibernate-mapping>
Take our tour and find out more about liveBook's features:
- Search - full text search of all our books
- Discussions - ask questions and interact with other readers in the discussion forum.
- Highlight, annotate, or bookmark.
- You learned how to create and execute queries. To create queries, you use the JPA query interfaces and process typed query results. You also saw Hibernate’s own query interfaces.
- You then looked at how to prepare queries, taking care to protect against SQL injection attacks. You learned how to use bound and positional parameters, and you paged through large result sets.
- Instead of embedding JPQL in Java sources, you can name and externalize queries. You saw how to call a named query and different ways to define queries: in XML metadata, with annotations, and programmatically.
- We discussed the query hints you can give Hibernate: setting a timeout, flush mode, read-only mode, fetch size, and SQL comment. As with JPQL, you saw how to name and externalize query hints.