pax_global_header00006660000000000000000000000064150444556440014525gustar00rootroot0000000000000052 comment=42dec9b2733e5bac898f8c903caeb6190accb7ee java-db-3.4.0/000077500000000000000000000000001504445564400130355ustar00rootroot00000000000000java-db-3.4.0/.gitignore000066400000000000000000000001061504445564400150220ustar00rootroot00000000000000.gradle /local.properties .DS_Store /build bin out .idea /*.iml tmp java-db-3.4.0/LICENSE000066400000000000000000000020671504445564400140470ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2016 Joshua Green Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. java-db-3.4.0/README.md000066400000000000000000000011111504445564400143060ustar00rootroot00000000000000# Java Database Wrapper Java wrapper for database various interfaces. ## Version 2.0 Release Database - stripped down to be more akin to a connection generator. DatabaseException - standardized exception thrown by library. DatabaseConnection - replaces most of the old functionality of Database. Exceptions are no longer swallowed. Query - query-builder helper class created. Row - Extracted from Database inner-class. ## Child Packages * java-db-mysql * java-db-mssql * java-db-android java-db-3.4.0/build.gradle000066400000000000000000000042231504445564400153150ustar00rootroot00000000000000group 'com.softwareverde' version '3.3.2' apply plugin: 'java' apply plugin: 'java-library' java { sourceCompatibility = JavaVersion.VERSION_11 targetCompatibility = JavaVersion.VERSION_11 } task makeJar(type: Jar) { manifest { attributes 'Implementation-Title': 'Java Database Wrapper', 'Implementation-Version': archiveVersion } duplicatesStrategy = DuplicatesStrategy.EXCLUDE with jar } repositories { mavenCentral() maven { url "https://jitpack.io" } } dependencies { implementation group: 'com.github.softwareverde', name: 'java-util', version: 'v2.9.2' testImplementation group: 'junit', name: 'junit', version: '4.12' testImplementation group: 'com.h2database', name: 'h2', version: '1.4.192' } tasks.withType(Test) { testLogging { events "passed", "skipped", "failed", "standardOut" showExceptions true exceptionFormat "full" showCauses true showStackTraces true debug { events "started", "passed", "skipped", "failed", "standardOut", "standardError" exceptionFormat "full" } info.events = debug.events info.exceptionFormat = debug.exceptionFormat afterSuite { desc, result -> if (! desc.parent) { def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)" def startItem = '| ', endItem = ' |' def repeatLength = startItem.length() + output.length() + endItem.length() println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength)) } } } } tasks.withType(Javadoc) { options.addStringOption('Xdoclint:none', '-quiet') } task sourcesJar(type: Jar, dependsOn: classes) { archiveClassifier = 'sources' from sourceSets.main.allSource } task javadocJar(type: Jar, dependsOn: javadoc) { archiveClassifier = 'javadoc' from javadoc.destinationDir } artifacts { archives sourcesJar archives javadocJar } java-db-3.4.0/gradle/000077500000000000000000000000001504445564400142735ustar00rootroot00000000000000java-db-3.4.0/gradle/wrapper/000077500000000000000000000000001504445564400157535ustar00rootroot00000000000000java-db-3.4.0/gradle/wrapper/gradle-wrapper.jar000066400000000000000000001630361504445564400213760ustar00rootroot00000000000000PK A META-INF/PK Am>=@?META-INF/MANIFEST.MFMLK-. K-*ϳR03-IM+I, dZ)%*%rrPK Aorg/PK A org/gradle/PK Aorg/gradle/wrapper/PK A%Ӧ/org/gradle/wrapper/BootstrapMainStarter$1.classRn@=Ӹu1Ey@_Iik6U@.,RuL!G 6 (ı ]t1ssչ_x󸳈ᾏM|4isZ}.kތ=ed/cΥei0c =<Ob+7.PmB%M -wźl6i<Z293#ұwںl hx8FEv~ė9P%pw8.R3S ѵAc+jgQEoN SzBzj\: zQ^oPK Ai,$ -org/gradle/wrapper/BootstrapMainStarter.classVSWsٰ,1*BI/VV(-m.!nvfjﭽ< %2ӗv;IIbٳ]7>1IF2^ C0%cA0#aVF d\{2Ǽd\UqBNPp]R2"!c7%|؉^|$A aQʋ .aI~ ee41rtSwN3+ U U䳕"E(ak{wuT-.Z黶9rhu48C, -펖64:n=n/whviX iFZ$K]hO&VoFWc-MDqhƛ:UTT;#RNvRzH$['tk=e&śoh86lsܕP=֣ ed,X: ׶`Զl"zϼNE/wۼ-j=𒶨y1/ [\f UevS/7,xBY|͙ZI,¶Cw\o4 Hn"#RGw Nb(Utm{ۣ*z*ch #9_xWchyG}ը/CCASs/A݇~8# ER7q%B# ܤ@-8q;Dv{K0*GcM%8NMUK;I1D %ĞↄDvNަDgy|px#UcU]@}iP8T(j@ 1*B qg)_X~:pDv%x}QJ \wWl~QI۵ 瓻x,Ȟ)W"MyŸi^;SܷsM C簸«NSd+:JEéxhTDf+TWkx:ɛ%e9ii1."4 e-a}G}OH??~RRę6 )$A5v\uhX Q~PLgn@Op{8 9'UD;v.BN%tm4 :Ӯ>@ZOT_1~#twdFJ8k$iJT'I'VnUI1Ii*:h X &(+78=h`Z}s -D̥xRϧr.р#A$q4 ?&`S}Z}_l1nb:݊3 ˦PK A#: !org/gradle/wrapper/Download.classY xu~Kpy(A,X'Ӓub$HD!YbBۑqbKi6M#%(IҸGz鑶i{%a,@h_ 3o޼̮^+_&M~/R];K#1c]KJџ{//i+|_hK;o;~^ZDॗEO*^Q_DyM4ᥗu/'hzGҏ Di/3%d2/}]*\H`EPU+OrxV I5 l^ hfhN4K^_e^l| oWyAU^*x^/H*oPAK 7zUn2ZS*oR.7EmBvwܦr;U[]*E,G w0iD°:z*eV1FtcIM=ocJuRF&HgNFŽEtf`o]`_/غOָk V,1Ti&RxPchޮ.&ꉩo@W(ts?dD`]g_ooW 4 t vwC]L{J20yؘnkhh=cɤavIX`ܫOL^ +3L9h.%VdX"fbꨟǂޛK040;0z#5 3LJu+&m y-Yfq[LҖ1;]*dS=zٍu"1r:4tֽ!5(z4*LCj"Fʎ%]k]g#FRLbqmNg0aVBcA:eX 'H(0%0in#1fH29@$si  ]K F!%0 2132# {06ai;o<\37ؗia0 LŠfq~6(TR1dg]= w)W} W8g1>+0f;E!t.aglN 1u^EfgƆ$H~Q &FM@2nJDd-/Ьv̰7e|15C2x*ʾXjAguV<&pzH2n+`ȬBgI r!C-cF# i<1O ?1+q'[|2iS-¦I~@cƤ0MsB"+Q#ZY b`2'᳢9Rpf-`gej *lz+꺰f4~&!<,]4+o<Ȍ8`r^iH6IJN7qiN w{RbGA0OV@O)#80BI `Q`L@`F҂%7bY*WyTPgZd]?.xXl"-5~ߍĜYLN]_QA3nGO!*|QiohpovgrK_m9;o%-{t[% ><$!Κց:Vo% - $L;J'&D l8+h1Ao9[N;9#tkÉbZg".yTT~m]Py~v+эܙ+Ap`/`(`/[%tq#Z\] 谮^,ɓ{^7I)3Ms!b">)J-3fĩhJkmJ9s7GF܋TUc-%ZîҸ8j}]wXs)YJQ,)pKEZ!s~ f%vamQɩ*|n\|R[v,99 ,,A~ VXU7 )nv:9i¦ngREUk"q3%޺d9g;U;4̟Ly@CqC~3eg{p|P;61!|MtM%\JLXAԬ|ȹHX|"~lmA.b'\qĭ}@^)5R漦-K6O!~;J8i8gmuv(>V9_ ykքnϲot01%"4iZFgl~| om0~h/_|>< 1c4DƳ'H1eh[I; nz[! Ue''@a*T0Epc$)WICŌI.LմV8oҦYymZ'[&{M'sIǺ>i-"Uޤ)CBEֻ.)C5= `fY!N)7]S jyzV}7(@N4yw6k6- O0MҒ^'CK ~$em[W2t߽`}mnw+ 6UVY_W3*cd\Z!Z9Z[STmu+.*䳪j5NT<0%Z&iƶ/Z]ujP_u-P akН3&5gh M hsxfhv2W&F[Mi!⯹qk8<?3hAdpu#O{Ԅ\DȒCA0O)B(F6AE܇9O<8(Jlh%ty MJp %y=[); Y'xڨ0t}.!Òa@EC )vU$(Ua/ߢ_@N-9^6x;`;ky 2/Us}>5T9 eU PhBV3 K 1^b7fbɵn+%yc$9S]Q>;-46y+ըF<? i hvo7~y{¾, nO< # &\$3R9<ĺekB/9:6W|FؔHEqEUPAo~ 3` 8,y =3Ů<ʃ. Aʰz;MJ`~Ze?JDvQޟ`F׳8z0snPOP|!חh0CCMa1>8̘gH[/d8j}`8:v+Ow[Kx!((㎏B((!}%5y%sE"u<\^M_D R}8znW|=#(b+Qxʦ%5Qǧ=< IŒM'/a$7AtV9;m[-$ڜ͗.r>c1"l5Y啂L٘~fܳ`7B$Z>S*LMc&2kwD$1(,IkDž6xNUeP؍Gy(4 =~'VCZO9t&.Ϻ\X85宣 ^!1%?k7_ߐ{M7?$*z吳iceiEus+p8_Ay PK AyL1org/gradle/wrapper/DownloadProgressListener.classu @E+jDE@ۖEERI#3c[>4v9OĪ.r%J[M DŽ,]8kߟ_PU:]3aG\^&at"-EeY˛8\3K tЎBNk؁PK A!9| 3org/gradle/wrapper/ExclusiveFileAccessManager.classWsWYګu|iVMNZ*;JlBNKƎ[t-vjSB[(P`x 3L$x0 }0+9%L=sݿOt]o3;6lKqoF3VB>%lW !8$` Dղ3"x D]AمEU WxcLQV$Cn.O#&A7zx N5@T3(zY4} ] ҳ4?Evqݏ<̏ LNp8>K.1Dg[A|4nkhLpSESv\c~]+蘭vvR5dw=#r<\KT8lo7`.ՐS WĮT U4]~T76v7BZ H ҫ@'c Klϓ31cDQDDwp>Pzp}@8B gmγ*& _$W +kr}FA?~(AZ8:ưq8 ӛ"؅Qc? z5)qjsDPh hF9҈u>c~iMȈvz5HM $?b)nIP$)SݳhѠǧB<q0.Ҷxd(WWw@M߉߭5S< a-sc-gONQM} (1#j R`뛿̀imP/QWM:;"+) Qgc@'Q)f! Ip @"pHwbo8=N%Ťډ;RN 8C?ӕ7oWy+V b3Bųl9ܭ9**$U<~PΫx^Kx{TJZ\/SrB+UtɯRj+akZu ^x 7)xxxX, *xw]rxE?.*>`XR0F|HeqE]LJ冏QPI| g<"9?+!I>//"؎ i?}GwvuDNh걭Xr`V3_ PޖH{[.˲g_W{o:Zbc,7  Z~JĒƮtaTҌ,gRK"54`q錥 VS3=v$%+03|dGn cY@"o-j#f6m VY&협2M-Fފ!JXg4kj5 =/2j&OHnX[\6sZǶC1!ґӟREtk_ڎśNk4"n HezE!,r_M~ֈmrI9 n)\™Jr^PPڬB2Kqf-Inڷkr{%mlmS663o,==Srr^7V'j[&F!T{̴5YrVHL6L2nG`#(DB7-P2&s Nsٖ |YjOS1X; ?5?V ̢CԩD ?B/+ 1kYb63R1Gs%qB{(,2\;Nxau%䋂g^W4Ox l؏!!vB`gSPyw\|w޼=yi7u4WqS.9,8V8s\[>$7{TiWGPY:NFQ7 e?_Fe_Yz2A8FIQrgA(uN#p$9&F9J)2:r@0G>̒RMŀmC|iL u1J/ٴb.%׎rB9,,G oE)2[;nV,ܣtԻ7f:5`jdؐ0[|g[qU:!lɪ6r g6[ aaO<0ùuPNYpiᬎ;Ug$~cO_-|{{ u)Gg>' ݋n9ȠS=.ƲPS9̵qw.prZ1b͊YS=Da(<,`*KPK A"org/gradle/wrapper/IDownload.classE 0  ^b* A{(l|JTf $_uX! ai'$|T:/ ?&NJ@XaXQГ7&zDVʙ&6X`-6L͉veLCz~@F@Y%H')9~<~WxL߰"Ni avyܲ'; WQ?/D\V+mĪM˩NjJjǢN4 55e-$| ¤iuMGOhSBWt%+i/ƌFKL\гva:Pљ^hw4*\kQ^\)6jkdQ|5\$5gʧ@yЊp6`&ƚewRr,oIښRe~멶\sngBs`2ҎKu1j4ZIWU|WP1PjYmlj 949U[:ycc)GܧvN45gjּyΚ !BRgyq)P1.(e%OWUNqMm;֚guhwX pg/0aŧM[˦mi9lHvX(65c ()X,J|{vg>BT᫪DTvjt7s1`t.Uz{̈́ze%ؒK)y9X튢u,5N V>]E#+K%TӗN >+*)P%ӃM,r{z77~;|n Q]]D]  Qfj-VI@wĚAO#=[`=eYDYBG7S2_ ӻV}\6T/z&pyg"D]թXB~i'>H6?e]G1< ˧LhYQbWfI+" & kX|!]ۗx+Z 3N`yte%XtLϚpp}';Ƞ.zG?lnyjOඖ@,d+/;m.PǶ-">G=dk-&ⱶϝ:ul ?g5 t%R}u2ei=[Ȳ"!&n▉Q\3a"e@XgX#-Ctۛ#a&QT Q z"H4H;4&('wJ:4OwYJ5N1. \ 0dy60uC.eQǨH~Zp&C%$,FٜB2LfL6=sT+еOТ't!uk*ߣ 34U xVȋI_=f%s &3lxѫwv+e/u6W.U1}d6PK Avp.- org/gradle/wrapper/Install.classY |T?'ax,0lH +aGb$%, K߼1 ]ZjV]肭$h*Z[jmk}~~M羙$y޻s?{-i/KS Lp rH< ϐ l>Sp ೤qq|_qIKti\\Rz[-xq ^:^&˥Y!t*exukA~VFDuBX"^A UXlIl[N٪q=;cgj]Ҵyޥn-|~O6_}#n6iVjljN&sqvs({fecp"|88)*NRG uUo<{y Ry~@4A H'I#X97씅k(IӮl1ӊEIhnP4O8-ljN2M퉔ūZz}ŠQ$?nE"1+!i6:c dQ:5!%T7K2R]"3?D +u_ F;#qlcSR j%Mo\5%Z.LR+u,>c[.NFq1 Y^F$!a9_2rS13=J,o)7*Ʈ@?'նDw_NbZXesy˿CIZgGM$YWzi[sq[Npe%zđ j11Q9.RT.ihnEPwH'6(aJBdvgt֝J(y(Kt+v6j{7'׳vW7 F\86h$;^]𵻶TnR-:ڢ$zuR,?ۉ ÷@%  ^CE1|]^< иA ϧGH?BʏVVqeGhaN'?ڹ)tdGoZ9<I"&2zԛAut=zD$ ϵ4iMeDW{C~*j?'4,*+>HEw:sd/RrnpVʹnOA"ip 2`n}nf3gsK3Vbm㸣ߍFL;JM4|f4yVx'ӷվBoޭ42맙+[Zy 䬃CIK@E?YpͩyV !iQ> 8JsOgyo!E4og'];'dwBIt6 ϥ(BP@bxIQZ@12y$fYTJQNVn @녉/W&I /ax~ Sv .ZN_n504 =_+ٯCtdnkt' X6~jT]C&^ё(8רM0•4xD2xTy/-`:@S JSi(;1Rs+*Gyy RAh ,S O~z_ != {\V$ڬCQ6\.{>L5e[)!&Z .Y\S 7xѱWԊվAZ y?#!If)g3ȵ*dҷ+;xSC=RI橷練>( s5=u|ፃ QW-iiZǚ&hRyli'9@zEH|/Vv ~M« Z-7.|((ɲnL;<漬s# gIL1~?f =bIcm~%C6=@ÃTR^MT⿟Z<z_<@9y|8rPZ?H[nMT-Ձ(lub%hȏbmMiv^SwStWh]pA?G`G?]O6hzހ$pME{=ݏ(MՀY-`0Xo\F?'Qcɓ8a_x 1fDyp݉ I)E@u\J[iP{S|s ho?< =PFA Bz. z n ciTmԐP8FKDB$;'z1]DtKbjzqZ~jo,/0#vsY9e:MT̊Bz&+UV0[G&Y)@VZDW֛9t!H 4WKX֫/fZBF`1^ŘS۔sJY?(?ooy֛`'KD%AAŲ&(v1'fHnӃt j16@Q-ҕ R4OɢPo.oA:l 'RL./k&/MA~O:A%X >$CWy-ױO{+2՟5x|2j?c-I|g}=5]ˡ " i8;NUņV5zP,y , Q|fb>b&pjrMfL+*Uwp5s6S^JXS>4'ZL8?g/ZCYUkjwj, [D*Kmtq*a'i1K,co W~ %B!4O-eGvg`ӝ"VT>uayq?^@˙\NX~U̹v? | qi3ou$-`fc<]99@S&;;eM*Z|<`?4dckqǐ{0#bvtUwxQ; 6m!W\5]1,)@F\s ˵w/'.Hqϰ3:NWfu-Ce"!lU#;m"x*@obw=Cj[$B# %qcI![3̔JgX&ovHIFi QV(Iؔ)r /,*ꊧP*qw(P&n_ݖ7ۛPK AJJ'8org/gradle/wrapper/PathAssembler$LocalDistribution.classQJ@=wj7EA(*(mۥnI٦`|(qv[Ī ̙3sf@Y0mf]̻X`pk\&poy @bW*IŐޕLsMh)50R8jT:㕐2~9+q/$W0fj%Zd8bHb[-A-XՃPw7B'<ڧ Sk? ~]$_S[GӸ %[!Ep=Xb(_ 1*BՃJCT;_qiXOLZ|- Fd ]PM~$ ov`?ghYIAk #eV4cxf"ТxoM@^R'X&@0+Nla)ק:#]PK Atx7&org/gradle/wrapper/PathAssembler.classV=cKy<^ 6vP@dIM2]o `FDD1$viKiBiBW˷M-;3l!{sw7p p?;0 MU\H*PAa/aJ;Kv%ۛ!5Am%-lce:i=(:BbW]S }B]6K& *? $%Mj\.WyOY xH#iXƓxJ*e<,2~WdQ[bJՔS~NAI&KbU"/z-~'20O>~PdO2ʄԊVL V@ilQ nkeuןCSS*DuÎSF5}ñ^Ɍ3mrMl.nn m2)ҝu4Se5RrRF5+tm83=[~xF `Stk/ֲ"ϦttRff;>k-VD/<<"JirPh)WeSpoDL޽&ӹqy|r?r 9&`$*B˴L`gn7_7/sWwrr;MP,."bQqՄUK{ |˲ղyӠ[Y7(=ހv 8 Uu~3IP~\Տ( ##x$SyLS>#ɺoM(EF\CbiLo%D5d XЙ6U+\C6:i%Wa @C=5 أ٣Jơ6B5U "Dc PF&\.zݤ\ :,wPz CR;-ӷ4Ef G I!Ҥ VOĉ`mWqó _g:ƆVK9#]Q۶͔nv-mνv^g-*6`Ja#Y" GAN l-|,g+[ *DŧL縥 |+||+Xyvy)'1MnBʶ6w{/(X,(~> Wٹ## I=(DWF$v t$0;/~*xBDV` -n|/#)yeǤ2FIi&^ʫ,=A5ٶTmMfRص/}6-ƷbU $egRevX|3%_ ๡~cg5hOW -a.5T cO_ {LP; e3y؆:J{3Pw@y42ESp~Gw"03V;LM`q=4/Z>u`iN]xG7Y κcA=#7? I4lv14$ ĨnqR!9KM-z9BԯrW)5" ,9z|~_=/!~L08WIH-_{M F1WU> =SpL<`ݖ_bqWPK A=?-org/gradle/wrapper/WrapperConfiguration.classmOAgJK|i " HULCߐ-H&~*M$&3w e&33_:a`@EG xL<2O<%xN8mPk35 QOM5)!Bw~+ 1sM(/;0/w^9sܰ nZd,8t|ZkZMlONlڍiv,.smns =NN8u ѽq$&L*A=HL)BCO*A4dF r_ s )%Ƞ 2)AeE, $!X yw y%^}93 2y~Oȸ`;)H^V0YW^а;98147243Ot KNj-;ޞ-#;[N3}Ht e]rbbAqy1ypȖmGCN$*= 8%g9ݲ =/az629uȐ Nl=qԤ1.aCi[Z:k?̝`iafRݘizoX4֔r!vSF`N3M-1z_arTQ5c!2xݮ\)&* ԉ^-ޫcd {Zn! ]$E锞s=' r|˝4g9yJ YE n ts@fJBU(E2DK2t!cj'-BFY&v\vwdLmz^B6i5~g#M ;{,5;UkUD u=*$$)-^QI?dIe ͞P#1F/Q0'i?e6!#(莄1eL%|%y,dKܢ"|j¡SRqm5U;^GQ˚h&}#Y܎I7w<}EA'LQQWMUόD2 }ʉx>1COG)7raWTN{Rӓ|88aAXTYoe݂zfuytR{:v:Z|`G_8檫x8󨊣~̕7:+x@-I :bqJ޻q(Kq6۷bj &};dm?JpE)@a ڦŕfhr%Q2&xglL->lDM6uFgºߏ C!̣Bh^GЮ hϳ_F~;=U7Ӿ˳_0kZcz8Ivzv0ixUñp,sϢfa\s oе(C BbjJ%%@,,V.ZX@3#8ꚑRM`:BBNcX@ xe,^F88isO[`IQfQ?b^ Ϣa ItV9gw"3X6;kcs9['_@cp qvC,bW/\ťl 9OC(.H']T !ٞ ތīS]hDLyW!p 5 kN=NRnp؜ch⟐ϔ4=c/-ePK A׃X ;org/gradle/cli/AbstractPropertiesCommandLineConverter.classV[WUN20 HԄKKIQJ;L0fOZZ_tA}N.i2Y9};vO6Q0e|`|`w,'? H` = V>Bx&c.cC i?]cЗ1-ci8"qB[׊kcrƔmeBhЋfb~MVd8i ޞf'$ F]p䙶0fv}-QԬB"9U ёѻE#0ff[-PvT4V5%\X3LXQgIWW]p0?:ĒVJFOMA`i ҮqA1\W@ \A܊A)5"ɓ48,FhJ+g ^zKŽa@7e2ZfYTRQxuWx8R E10ogm74Ӂr_q9\WOw/jhz"#z,Zi.ZFkP*؏$}iB+ c na]bᶂ1|( 2>R1>aʠSz5 xA$>UDP~.*8 %>Ä;g+ZEkߌM' g6-0 : NVϟ=!!{LX`e2zFI3U\%Ne5CC]Z]AၺmѸYCYbZ.+&%b `)s4 "(({j^<Q*>\{#%N׃\&9I~r)C09ymjV!:|k"%*5&@TZ[AkI )Zb=Nʆr2j s噜(B`4JY:TCaecU*b2vTzCɘgKEԷNR9r,m:BM}V{"O.6u1᳠~-g~hWKt/Ovs }+ =]hY,l$ ֊7 4O? gԻ h;_!ѸwiPCEӞEVh`ll ,[m'GT&p DAnE!i/8<~[$"V8zb3%+>g*h/V!r'em3=:Irn wN0!؊u2aIPK AD&3org/gradle/cli/CommandLineParser$AfterOptions.classmOA{-r- >W+p"D!$MFxag9.D%2^rҒcffwn׷fqۀQiu4h IStLaTzj6Pɓ5&yյXOlե}G8]x2Crɫ< +M[>.YN w\:JIi0dmxBBr卆Mu0r$fu~^F+[.5k՗-o0$z<AekͨS bVgcg>v@]7|- ƪ-+CG@ϔ0 jE7 7ckމW7xؒ1f00yd835?UѶ= q~ :5hhkmq_2wC^2 \ G@I]TGi4gL,~AbT 4"A;`ȑm:C٤3qhboPK AMu <org/gradle/cli/CommandLineParser$BeforeFirstSubCommand.classVrT串:I I|skiK^rը,Ӿ[2xHnbN0Ϲٳ=_~02Nc K2ȑ!aYFø ǪP&Cu!%6>1u(68 woz|a,oٕLVzF5VSawU9^6Lùps_u Wݢd֬ml4jeݾ$-Mn!M$2 -[au(7m2(MSתjڢ/xWCiX;PBNg, YtT)}3%l1T3,zoKf=H9 T_1$wbW5t?fk5s$]%4C Y Gp|@EYx.~H@]*[qrj;;kG柮G&İSEQɪz|q|ypj( mja8 ˔Ww[E^lq6v(=WN##rNYS.8~rWßK*b; Q"QiD@r0M[Ҭ$?!HvCIqf.Ɇ1JᮨoZ }4{JEFG?3x/J#'Gtr)Ipg{(EOJT).>Gd/-GWZo=sP#`K3Q[F]F]pՅڇbYh@~R (!ijJ3n8B# gHWܱa6:Nx*9g\.{b ׹ڸi^E` N$,SDgqc)/hRPK A*ZMForg/gradle/cli/CommandLineParser$CaseInsensitiveStringComparator.classS]OA=wPRˇ"UhAx1MLԏvn/`|EkC9{Ng?&6 Q)`,95=K&lfc*!|m2]Bt%a||ߓzGy)vV&+"M?~"u$ۑV~Q Nnx" %6m܏#nԍ֛uB_Є"[f)ְm*ȧHjfp\p ߩLbs E"Ld'h@Kӟ0}1/d MXEnqsYX'>9|r9\=wP5oy$L̑iftcye}ly:E1k-LYn3q2\uM&:c#2Oȭ㿈(&J`R؁p6k0,X\*wM/PK A|R&=org/gradle/cli/CommandLineParser$KnownOptionParserState.classXwU6ͤK*EqDt;VkEE+. ɐ3uf҂HQpCqP![>u\|I\@-V< gZY͓5ͨ-4Τjת 窬m͵l Znpi S5꿗$뻦 b^)Std%fsTCP`g^ t H@'؄Nr"#^hNoGQ7AUߑt$ YFRk|yaC@gpPn'I<:\(=Ěp,᝛aұV6dhd F^wމ& aࠑW~qpN߽̾2BI 7!?PK A$ľ<org/gradle/cli/CommandLineParser$MissingOptionArgState.classmOPw*LD ! ·'`0W̚o;oB~?ܶK˒s~퟿~Œr:'I*(uZG 7ٌqeМ-rD_K.]Sz3Bjs5]#ņu,nV4\k0#%rw[cU:3 WZ S69^RzxZsu-˲V;TJ?nI/GQw|m.UORn!eCw&à# ֻ @~+:0r`#:L:՞ͭ1𦯉)[PR2q\U%7ǖڒ#63Vt201,K`=org/gradle/cli/CommandLineParser$OptionAwareParserState.classUn@=q$6\%)MK@)p)E E*oĮO x$ J|Mݒ*A./ޝgf퟿PĽ8ȩ0*wTzc\ *L+(cVAQu4ܮ,dȖQ/5̂Ѱ OpC{i\e˶; ` CdթQIh5xƫ 7*\X.Cɶg9Zŵu6jI,s]SMj%} P녲',4!E]&8c$${]pG짍oRNK%ti!ӘЏSnbX[XPa sLf +~a[f:~Z)9hOS csmqr |FdUԩ0L-=ƽ_qkޥvrl0.ϥF|x!JӚ'vt!}rOYY,T6$a|iZ ̋dKTTȇC(Z7D!eSZ2B#oo+5UcCݢ{ B*^v#8GNi$y6+1E83$r]oPK A%̻7org/gradle/cli/CommandLineParser$OptionComparator.classTmOP~Q: 2@.,Ydďe4kI?/~#ƨ_ N6).]}s=~ E%d0#0+bNUJ"E,IHs;'"V8|USk"z6L7eA(;íi;- Vn)L!{䛎]vG Wlp˖y!P~`j2U6uyN_z`QWkH-T T|%|4y`P?UKjwMkwuz-֤$/0L[3xѪM7-O7 IRiu;?ڑ~Sb@ZaBhΟ\ia+6eYgљ{"!c /&q va[hǂZ00 }m j]{a=eўB$>P}4s2|=ѧQ*te躣K.@ >rd d$S3gH|$%!zp'a!xD"2{9 O蹀Sp HswnL8trI"!y3Ⱥ2GYv>i<2<l4!M{nV  #fdY"5>{}FCNS#ZOqϣHINQ2(R8˦Sqv[lB|'9乎OE;McBһ-!%."{N'MzzY%B65[m~kETBZƓq5<]/h}LѾ>McGMHx)PK A`M~U2org/gradle/cli/CommandLineParser$ParserState.classSoPN) s97ս&MLf.а.vF'_|(- AGmdQC-6xbaB{I/zI4\jϓdbs ?4iF^H(*tU?'tUav/Pcgw9`2r;$uTyP/#}@3I8c)O;B / Z &Wti2qfYC!zPڕh&ߗP2egvnӁ$$T@|*>A%W|):T Џ3_qI_q3!Źt^= xc @C!:Z_ eYq>8YMHEFw@@9\"!vCz1v񫮥x&҃k$}ˌf!uTsj]p99+1:*4*4fE!./1Y ?PK A=l)&org/gradle/cli/CommandLineParser.classYi`\őJ7zzeٲ=`l1S>K6XzFψ8B``d MͲaك= !l~ޛPwOwUuUuO{YT:jW5ױh/>)s3 O >ס yRa#||1ׄW%GģcxS5E]%_fFeu֤Pt|e&cuq8&&䞬JO|7#P"tM$(L8?=cq3֔&LMssOA0eAQC(j]Z-um 3f5if ≦mkG0JKͶh̚dcu;13cM0[1׬_ݸa5u֭X( ^N1U&VQQ[٥=IҨ]k G-\FګmWEc`kجn V"E9:Gw6v1|yqe41P<-l҉H(H[Rs,Jؽc[-`,~;DG|Kglloi5M% 9.bI+v"[FURo;R`FN3#mL= 4P%$lu * cLate+r"nuUCiظ̀J]B\ kX5Pj:)Bp(^Hi%n Zkn ݒ_>N &3A32g R4d Z8?lyOm'ˆf@hՌ%sƞUu63iʭ ŕ%p77DL^aE9͚V\EW p vX8)4iFf(Ma}.l?F,N@6 7w3§E5Fp J-fn1R^:t[BYԙd3R÷M΄A-Vvmϼ.(SYnZQ_;S[Zx|ڜ3KFR^9fpUg sPY1O/ }MX k#IRr ܊[ ܀ ܬFD- ;&-i{OP<1Mڹt\͐׍ku;5nHXv!]r1% 0Ґt *1T]Bحt-씸!ǐK2C.+%ª2C!W*or\MxղZmU3Wq\lE,rRz[UV3[r!7(G(Wr|ېjCn*%*Ų!wYX2u]4yӇY <'kP͝%w't3luY9LُC'dR{23$* 0d\/!{^C/hr7ܟŞkCPɈ: \lȃnяEb`*ƹc&{>Vi%=f ٽwbeic^Rĉ^Éww` OF3<,dn>g?_y2|% zX>"Nd1VfY72pLbh1s}6=JqŴ*9DuXUǻ?}e[ւeN(q%B=:FsWz~-)u+Z v{p,|{`8E< r_n۷Cc^{[܉բzv 46<[]kt6SNo;:ԃCqֻ[c`|ݽ(~zvV7\e"z>LP_kp6#+Lh1I`E4c/]AinعnV0=tziH_r3 %?~u'\vB A 7o}mh~ ǡWs _&%@,yő<ހ M3y⼃N wnW})m^YAhO YL+,l"G˱7<7hb>xi!_ph 9Q}( a`F˜Zoeۋ局v}r8i7N"eK{1\NIAU[k|6e)=LgitE:Rt=("4RA~?(N{,$)>ȡ)Y>gGK;Ȯ,J͡%TZX֋rE\ދ O܍€?i.UMj[W\V *Rv"uGYxm;>,.ӇK֑lwlfe/NoE'QbWb#`cm3< ؊_"K *#`x)hbtH):Ll&evH'҅.M^Q~;9˸T7C\)5?z9sr*hp?ۻ0=Q֜F {twtc1~DkUa!t0F!SE/wXS'Md_ø8缁羑gM'9K (=SX-,3,-N=uS9Pi Qc"%p;°s`qx<6V~,z*-wFG|:%f)XJXBV4[J^ ϑ^lT{ pg9܅*+/#ߒZJNxy*uìR6+|*,&VUV} 5^ƇbiҕbYЇ5y\$h:4"i4hpm7H8T ^Rx 0K%kAg鵓r7s~!o_ǜ9`9_K_$,+ J;~);܆%!Myxw#){9%qG2wR0 /r5{,5qBH\ d^pKPΓ7xY+b܋7X:yxY絲F园ɯS-18gO{zSe yNva`aZx 5mCd"QLtLq:ɛ ec%,3w]}sS}~e?2<_p媲>lJ0ݩjA^i uoQEpê8~?oSw/-Oijwg޶K/UGy^}B,ZJ,;;ɢxbf9rKa2J|ߋs=ijS8TPqhQnsʃYQU@O~lm.I=oA`2/-'a*o}CӑMswōiV*,K:&U@cHb{V5kyE=!#&P== kOц?r]?1>gAy{8u ca*^H*R!Vg-yh.#fN>_{EV43$ffN8Ѭ;ldO sN]wai ;{g>.a.=dzA#_;q eV)^?PK A>&org/gradle/cli/ParsedCommandLine.classWiwg~Fċ%vTMc[R8S)-LT(.Ph١li7 `rX;Ɵ}g$Kָ1G}.3ǽ?.v*`!*΢ .bufT,.+*WBM0#h'".T=^a}:|Fkt 0^7/㋸$__V0AVMa q[ ͼ1s#+3ɥ/E; f2n-C#2iҖ U0RҒKMfr)y(Q0r*T>c4yZq%sH˶YhM-C#\U08a~.k *)CxK )LAt\гkWYp#A͙ FA|Wݳw/뀽)xV5KԶx:ԕ|)#wOPccI(V^yU6KbѴ\j3TpUG(|VQH1M 7S8 RΊ|{Y#۶nQ/5^kKouO;=Fm,Rhq35$bwcLOFܙm Ln"9mG7Mhz*gJwrv詔DճEc YeyK?a{?՜qZ:fyȌYcm5 ^Xdkޏဂ6Y"|P[x[w= 1s=>4?RcfUDO38*$c/GW*S.5“~Un |ɘ_=0a 4 WU\0~pWLHZϖ:zypy*rK}jc븪֒[v.2}Ric9SVUPPIΝir+9gS QZyۇOBMkI'ƠG> =7rW=¶~̜gD1[f(O :6yP=𸟳J8Je2msQP0-^^Ц5[y?AC2?TjH܆mo"@1H1tXG1r}kL%װCРh&4o! ;]LHҰe(=Z[];7d?k'Wo A؅속=x5:ICab!Zcx(Dp1')1a8!N**&T=thT_P;='X/ FΙbX@u #Bwvp\}b9ûx?}dT}HH.o!syVOCI/a$qaxA1cx)R_J@{& (+}?Av3xG f97CTEB"]tF.'ޜ軅؜t<õ2i 1i_3%6 ;Aؓq6A-V4RgZlG orN$gdyE:+N:$̕ųxU '\5B%ǻ6 Z3]^ᜐk>lJ ;k>e'*6zEGe)A<],;[S;\Or=l8>Y ߀^9ي NLvczͭ&@S܇Қg\HVvWc .97{XŘ㰗Go )ȑ,I8sQHI 0$Abs9{`_i*^QUt  9%<' tEB^Krvs?`A^EAEXP QP dȹPK AytE,org/gradle/cli/ParsedCommandLineOption.classS]O@=ݯGePaeQ"hHV1YawRlIgN[`Y$ә{=?“4(H#b 冊$4-L%q[器+r⾊ [lpWAɶ(Ha1p#-g,C/{9*I Kxs UEJ%a:w^u"]a*s!"k~E쳟}V_*bTG;-%bXo"p(=@&_2w%^*$APPS =1D:!䉩If%ޱn05W(vbRD $"xj2Dϧxr7k> !V.p].GӱD\8"y RPK A\vB| :org/gradle/cli/ProjectPropertiesCommandLineConverter.classKO@D|?Pâu#Q+$C;1m  JW&.(1D,9vo/[@yl汕G)v }FHWkwLS!]nY7ZK:̿cJDZRysV;H+-)nkS#cruLXgh|BjFYDΏ%L%񎅎*_?ֈ:("<ڄbJՍ ؊tf^*K ߵ XUVi01k p8wZ8T0g?PaΛm=C Ss | 1\Zq-}C_JEˉjE+ w'PK A 8=|9org/gradle/cli/SystemPropertiesCommandLineConverter.classJ@ثmjE5BPąR/P~ӑ$&BJW 'iAY3͜l "lYlE <& d@HgL{:rRs:C*X4NĬQ ۴;hZ3a ѽG!]Gv7S"5eb o}ɸGtFMz9y~X{()spL`7e.KV, TXxɢfDTEGPWJmh~49AjxѰ sh gԙn85].FԒs9Q΢*s/@Ug J*ce+s+1 $p6/t-,;h-.Z >kZPK A?gradle-cli-classpath.properties+(JM.)**+MPK A%gradle-cli-parameter-names.propertiesPK A AMETA-INF/PK Am>=@?)META-INF/MANIFEST.MFPK AAorg/PK A Aorg/gradle/PK AAorg/gradle/wrapper/PK A%Ӧ/org/gradle/wrapper/BootstrapMainStarter$1.classPK Ai,$ -#org/gradle/wrapper/BootstrapMainStarter.classPK AhQ}#org/gradle/wrapper/Download$1.classPK A 1;Ap org/gradle/wrapper/Download$DefaultDownloadProgressListener.classPK A-L4 org/gradle/wrapper/Download$ProxyAuthenticator.classPK A#: !uorg/gradle/wrapper/Download.classPK AyL1 org/gradle/wrapper/DownloadProgressListener.classPK A!9| 3u!org/gradle/wrapper/ExclusiveFileAccessManager.classPK A,y-|(org/gradle/wrapper/GradleUserHomeLookup.classPK Ac67 *@+org/gradle/wrapper/GradleWrapperMain.classPK A"/5org/gradle/wrapper/IDownload.classPK A9lV"6org/gradle/wrapper/Install$1.classPK A $|->org/gradle/wrapper/Install$InstallCheck.classPK Avp.- vAorg/gradle/wrapper/Install.classPK A:o4WVorg/gradle/wrapper/Logger.classPK AJJ'8Yorg/gradle/wrapper/PathAssembler$LocalDistribution.classPK Atx7&Zorg/gradle/wrapper/PathAssembler.classPK A| 0aborg/gradle/wrapper/SystemPropertiesHandler.classPK A=?-qgorg/gradle/wrapper/WrapperConfiguration.classPK AG (ljorg/gradle/wrapper/WrapperExecutor.classPK Ae #sgradle-wrapper-classpath.propertiesPK A)'tgradle-wrapper-parameter-names.propertiesPK AAptorg/gradle/cli/PK A?<S1torg/gradle/cli/AbstractCommandLineConverter.classPK A׃X ;*worg/gradle/cli/AbstractPropertiesCommandLineConverter.classPK A}yGK1{org/gradle/cli/CommandLineArgumentException.classPK Ag)q}org/gradle/cli/CommandLineConverter.classPK ASf g&~org/gradle/cli/CommandLineOption.classPK A튯(org/gradle/cli/CommandLineParser$1.classPK A$f{K ;org/gradle/cli/CommandLineParser$AfterFirstSubCommand.classPK AD&3org/gradle/cli/CommandLineParser$AfterOptions.classPK AMu <org/gradle/cli/CommandLineParser$BeforeFirstSubCommand.classPK A*ZMForg/gradle/cli/CommandLineParser$CaseInsensitiveStringComparator.classPK A|R&=org/gradle/cli/CommandLineParser$KnownOptionParserState.classPK A$ľ<˚org/gradle/cli/CommandLineParser$MissingOptionArgState.classPK ATK>=ʝorg/gradle/cli/CommandLineParser$OptionAwareParserState.classPK A%̻7Ϡorg/gradle/cli/CommandLineParser$OptionComparator.classPK AfC8ߣorg/gradle/cli/CommandLineParser$OptionParserState.classPK AE3ܥorg/gradle/cli/CommandLineParser$OptionString.classPK AgAqx=بorg/gradle/cli/CommandLineParser$OptionStringComparator.classPK A`M~U2ǫorg/gradle/cli/CommandLineParser$ParserState.classPK ApX k?org/gradle/cli/CommandLineParser$UnknownOptionParserState.classPK A=l)&Uorg/gradle/cli/CommandLineParser.classPK A>&org/gradle/cli/ParsedCommandLine.classPK AytE,org/gradle/cli/ParsedCommandLineOption.classPK A\vB| :org/gradle/cli/ProjectPropertiesCommandLineConverter.classPK A 8=|9org/gradle/cli/SystemPropertiesCommandLineConverter.classPK A?gradle-cli-classpath.propertiesPK A%gradle-cli-parameter-names.propertiesPK66java-db-3.4.0/gradle/wrapper/gradle-wrapper.properties000066400000000000000000000003121504445564400230010ustar00rootroot00000000000000distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists distributionUrl=https\://services.gradle.org/distributions/gradle-6.4.1-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists java-db-3.4.0/gradlew000077500000000000000000000132121504445564400144070ustar00rootroot00000000000000#!/usr/bin/env sh # # Copyright 2015 the original author or authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ############################################################################## ## ## Gradle start up script for UN*X ## ############################################################################## # Attempt to set APP_HOME # Resolve links: $0 may be a link PRG="$0" # Need this for relative symlinks. while [ -h "$PRG" ] ; do ls=`ls -ld "$PRG"` link=`expr "$ls" : '.*-> \(.*\)$'` if expr "$link" : '/.*' > /dev/null; then PRG="$link" else PRG=`dirname "$PRG"`"/$link" fi done SAVED="`pwd`" cd "`dirname \"$PRG\"`/" >/dev/null APP_HOME="`pwd -P`" cd "$SAVED" >/dev/null APP_NAME="Gradle" APP_BASE_NAME=`basename "$0"` # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD="maximum" warn () { echo "$*" } die () { echo echo "$*" echo exit 1 } # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false nonstop=false case "`uname`" in CYGWIN* ) cygwin=true ;; Darwin* ) darwin=true ;; MINGW* ) msys=true ;; NONSTOP* ) nonstop=true ;; esac CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables JAVACMD="$JAVA_HOME/jre/sh/java" else JAVACMD="$JAVA_HOME/bin/java" fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else JAVACMD="java" which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi # Increase the maximum file descriptors if we can. if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then MAX_FD_LIMIT=`ulimit -H -n` if [ $? -eq 0 ] ; then if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then MAX_FD="$MAX_FD_LIMIT" fi ulimit -n $MAX_FD if [ $? -ne 0 ] ; then warn "Could not set maximum file descriptor limit: $MAX_FD" fi else warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" fi fi # For Darwin, add options to specify how the application appears in the dock if $darwin; then GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" fi # For Cygwin or MSYS, switch paths to Windows format before running java if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then APP_HOME=`cygpath --path --mixed "$APP_HOME"` CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` JAVACMD=`cygpath --unix "$JAVACMD"` # We build the pattern for arguments to be converted via cygpath ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` SEP="" for dir in $ROOTDIRSRAW ; do ROOTDIRS="$ROOTDIRS$SEP$dir" SEP="|" done OURCYGPATTERN="(^($ROOTDIRS))" # Add a user-defined pattern to the cygpath arguments if [ "$GRADLE_CYGPATTERN" != "" ] ; then OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" fi # Now convert the arguments - kludge to limit ourselves to /bin/sh i=0 for arg in "$@" ; do CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` else eval `echo args$i`="\"$arg\"" fi i=`expr $i + 1` done case $i in 0) set -- ;; 1) set -- "$args0" ;; 2) set -- "$args0" "$args1" ;; 3) set -- "$args0" "$args1" "$args2" ;; 4) set -- "$args0" "$args1" "$args2" "$args3" ;; 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; esac fi # Escape application args save () { for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done echo " " } APP_ARGS=`save "$@"` # Collect all arguments for the java command, following the shell quoting and substitution rules eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" exec "$JAVACMD" "$@" java-db-3.4.0/gradlew.bat000066400000000000000000000057621504445564400151640ustar00rootroot00000000000000@rem @rem Copyright 2015 the original author or authors. @rem @rem Licensed under the Apache License, Version 2.0 (the "License"); @rem you may not use this file except in compliance with the License. @rem You may obtain a copy of the License at @rem @rem https://www.apache.org/licenses/LICENSE-2.0 @rem @rem Unless required by applicable law or agreed to in writing, software @rem distributed under the License is distributed on an "AS IS" BASIS, @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @rem See the License for the specific language governing permissions and @rem limitations under the License. @rem @if "%DEBUG%" == "" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @rem @rem ########################################################################## @rem Set local scope for the variables with windows NT shell if "%OS%"=="Windows_NT" setlocal set DIRNAME=%~dp0 if "%DIRNAME%" == "" set DIRNAME=. set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @rem Resolve any "." and ".." in APP_HOME to make it shorter. for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if "%ERRORLEVEL%" == "0" goto init echo. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :findJavaFromJavaHome set JAVA_HOME=%JAVA_HOME:"=% set JAVA_EXE=%JAVA_HOME%/bin/java.exe if exist "%JAVA_EXE%" goto init echo. echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :init @rem Get command-line arguments, handling Windows variants if not "%OS%" == "Windows_NT" goto win9xME_args :win9xME_args @rem Slurp the command line arguments. set CMD_LINE_ARGS= set _SKIP=2 :win9xME_args_slurp if "x%~1" == "x" goto execute set CMD_LINE_ARGS=%* :execute @rem Setup the command line set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar @rem Execute Gradle "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% :end @rem End local scope for the variables with windows NT shell if "%ERRORLEVEL%"=="0" goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 exit /b 1 :mainEnd if "%OS%"=="Windows_NT" endlocal :omega java-db-3.4.0/scripts/000077500000000000000000000000001504445564400145245ustar00rootroot00000000000000java-db-3.4.0/scripts/clean.sh000077500000000000000000000000661504445564400161470ustar00rootroot00000000000000#!/bin/bash ./gradlew clean rm -rf out 2>/dev/null java-db-3.4.0/scripts/make-jar.sh000077500000000000000000000002351504445564400165520ustar00rootroot00000000000000#!/bin/bash rm -rf out/bin 2>/dev/null mkdir -p out/bin ./gradlew makeJar && cp $(ls -tr build/libs/*.jar | tail -1) out/bin/. && chmod 770 out/bin/*.jar java-db-3.4.0/scripts/run-tests.sh000077500000000000000000000000351504445564400170250ustar00rootroot00000000000000#!/bin/bash ./gradlew test java-db-3.4.0/settings.gradle000066400000000000000000000000341504445564400160520ustar00rootroot00000000000000rootProject.name = 'java-db'java-db-3.4.0/src/000077500000000000000000000000001504445564400136245ustar00rootroot00000000000000java-db-3.4.0/src/main/000077500000000000000000000000001504445564400145505ustar00rootroot00000000000000java-db-3.4.0/src/main/java/000077500000000000000000000000001504445564400154715ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/000077500000000000000000000000001504445564400162475ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/000077500000000000000000000000001504445564400211275ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/database/000077500000000000000000000000001504445564400226735ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/database/Database.java000066400000000000000000000001541504445564400252420ustar00rootroot00000000000000package com.softwareverde.database; public interface Database extends DatabaseConnectionFactory { } java-db-3.4.0/src/main/java/com/softwareverde/database/DatabaseConnection.java000066400000000000000000000017021504445564400272620ustar00rootroot00000000000000package com.softwareverde.database; import com.softwareverde.database.query.Query; import com.softwareverde.database.row.Row; import java.util.List; public interface DatabaseConnection extends AutoCloseable { void executeDdl(final String query) throws DatabaseException; void executeDdl(final Query query) throws DatabaseException; /** * The insertId is returned, if applicable. * Otherwise, a zero is returned. */ Long executeSql(final String query, final String[] parameters) throws DatabaseException; Long executeSql(final Query query) throws DatabaseException; /** * Returns a list of rows upon success. */ List query(final String query, final String[] parameters) throws DatabaseException; List query(final Query query) throws DatabaseException; void close() throws DatabaseException; /** * Returns the underlying Sql Connection. */ T getRawConnection(); }java-db-3.4.0/src/main/java/com/softwareverde/database/DatabaseConnectionFactory.java000066400000000000000000000002331504445564400306100ustar00rootroot00000000000000package com.softwareverde.database; public interface DatabaseConnectionFactory { DatabaseConnection newConnection() throws DatabaseException; } java-db-3.4.0/src/main/java/com/softwareverde/database/DatabaseException.java000066400000000000000000000006221504445564400271210ustar00rootroot00000000000000package com.softwareverde.database; public class DatabaseException extends Exception { public DatabaseException(final String message) { super(message); } public DatabaseException(final Exception baseException) { super(baseException); } public DatabaseException(final String message, final Exception baseException) { super(message, baseException); } } java-db-3.4.0/src/main/java/com/softwareverde/database/DatabaseInitializer.java000066400000000000000000000016271504445564400274540ustar00rootroot00000000000000package com.softwareverde.database; import com.softwareverde.database.properties.DatabaseCredentials; import com.softwareverde.database.properties.DatabaseProperties; public interface DatabaseInitializer { interface DatabaseUpgradeHandler { Boolean onUpgrade(DatabaseConnection maintenanceDatabaseConnection, Integer previousVersion, Integer requiredVersion); } /** * Creates the schema if it does not exist and a maintenance user to use instead of root. */ void initializeSchema(DatabaseConnection rootDatabaseConnection, DatabaseProperties databaseProperties) throws DatabaseException; DatabaseCredentials getMaintenanceCredentials(DatabaseProperties databaseProperties); Integer getDatabaseVersionNumber(DatabaseConnection databaseConnection); void initializeDatabase(DatabaseConnection maintenanceDatabaseConnection) throws DatabaseException; } java-db-3.4.0/src/main/java/com/softwareverde/database/KeyValueStore.java000066400000000000000000000003541504445564400263020ustar00rootroot00000000000000package com.softwareverde.database; public interface KeyValueStore { String getString(String key); void putString(String key, String value); Boolean hasKey(String key); void removeKey(String key); void clear(); } java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/000077500000000000000000000000001504445564400235755ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/JdbcDatabase.java000066400000000000000000000004641504445564400267330ustar00rootroot00000000000000package com.softwareverde.database.jdbc; import com.softwareverde.database.Database; import java.sql.Connection; /** * Convenience interface to avoid specifying the generic type everywhere when using JDBC. */ public interface JdbcDatabase extends Database, JdbcDatabaseConnectionFactory { } java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/JdbcDatabaseConnection.java000066400000000000000000000177361504445564400307650ustar00rootroot00000000000000package com.softwareverde.database.jdbc; import com.softwareverde.database.DatabaseConnection; import com.softwareverde.database.DatabaseException; import com.softwareverde.database.jdbc.row.JdbcRowFactory; import com.softwareverde.database.query.Query; import com.softwareverde.database.query.parameter.TypedParameter; import com.softwareverde.database.row.Row; import com.softwareverde.database.row.RowFactory; import com.softwareverde.util.Util; import java.sql.*; import java.util.ArrayList; import java.util.List; public class JdbcDatabaseConnection implements DatabaseConnection, AutoCloseable { protected static final Long INVALID_ID = -1L; protected static final Integer INVALID_ROW_COUNT = -1; protected final RowFactory _rowFactory; protected final Connection _connection; protected Long _lastInsertId = INVALID_ID; protected Integer _lastRowAffectedCount = INVALID_ROW_COUNT; protected TypedParameter[] _stringArrayToTypedParameters(final String[] parameters) { if (parameters == null) { return new TypedParameter[0]; } final TypedParameter[] typedParameters = new TypedParameter[parameters.length]; for (int i = 0; i < parameters.length; ++i) { typedParameters[i] = new TypedParameter(parameters[i]); } return typedParameters; } protected Long _extractInsertId(final PreparedStatement preparedStatement) throws SQLException { try (final ResultSet resultSet = preparedStatement.getGeneratedKeys()) { final Long insertId = (resultSet.next() ? resultSet.getLong(1) : null); return Util.coalesce(insertId, INVALID_ID); } } protected PreparedStatement _prepareStatement(final String query, final TypedParameter[] parameters) throws SQLException { final PreparedStatement preparedStatement = _connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS); if (parameters != null) { for (int i = 0; i < parameters.length; ++i) { final int parameterIndex = (i + 1); final TypedParameter typedParameter = parameters[i]; switch (typedParameter.type) { case STRING: { preparedStatement.setString(parameterIndex, (String) parameters[i].value); } break; case BYTE_ARRAY: { preparedStatement.setBytes(parameterIndex, (byte[]) parameters[i].value); } break; case WHOLE_NUMBER: { preparedStatement.setLong(parameterIndex, (Long) parameters[i].value); } break; case FLOATING_POINT_NUMBER: { preparedStatement.setDouble(parameterIndex, (Double) parameters[i].value); } break; case TIME: { preparedStatement.setObject(parameterIndex, parameters[i].value, JDBCType.TIME); } break; case DATE: { preparedStatement.setObject(parameterIndex, parameters[i].value, JDBCType.DATE); } break; case DATETIME: { preparedStatement.setObject(parameterIndex, parameters[i].value, JDBCType.TIMESTAMP); } break; } } } return preparedStatement; } protected void _executeAsPreparedStatement(final String query, final TypedParameter[] typedParameters) throws SQLException { try (final PreparedStatement preparedStatement = _prepareStatement(query, typedParameters)) { preparedStatement.execute(); _lastInsertId = _extractInsertId(preparedStatement); _lastRowAffectedCount = preparedStatement.getUpdateCount(); } catch (final SQLException exception) { _lastInsertId = INVALID_ID; _lastRowAffectedCount = INVALID_ROW_COUNT; throw exception; } } protected Long _executeSql(final String query, final TypedParameter[] parameters) throws DatabaseException { try { if (_connection.isClosed()) { throw new DatabaseException("Attempted to execute SQL statement while disconnected."); } _executeAsPreparedStatement(query, parameters); return _lastInsertId; } catch (final SQLException exception) { throw new DatabaseException("Error executing SQL statement.", exception); } } protected List _query(final String query, final TypedParameter[] typedParameters) throws DatabaseException { try { if (_connection.isClosed()) { throw new DatabaseException("Attempted to execute query while disconnected."); } final List results = new ArrayList(); try (final PreparedStatement preparedStatement = _prepareStatement(query, typedParameters); final ResultSet resultSet = preparedStatement.executeQuery() ) { while (resultSet.next()) { results.add(_rowFactory.fromResultSet(resultSet)); } } return results; } catch (final SQLException exception) { throw new DatabaseException("Error executing query.", exception); } } protected JdbcDatabaseConnection(final Connection connection, final RowFactory rowFactory) { _rowFactory = rowFactory; _connection = connection; } public JdbcDatabaseConnection(final Connection connection) { _rowFactory = new JdbcRowFactory(); _connection = connection; } public Integer getRowsAffectedCount() { return _lastRowAffectedCount; } @Override public synchronized void executeDdl(final String query) throws DatabaseException { try { if (_connection.isClosed()) { throw new DatabaseException("Attempted to execute DDL statement while disconnected."); } try (final Statement statement = _connection.createStatement()) { statement.execute(query); } } catch (final SQLException exception) { throw new DatabaseException("Error executing DDL statement.", exception); } } @Override public synchronized void executeDdl(final Query query) throws DatabaseException { this.executeDdl(query.getQueryString()); } @Override public synchronized Long executeSql(final String query, final String[] parameters) throws DatabaseException { final TypedParameter[] typedParameters = _stringArrayToTypedParameters(parameters); return _executeSql(query, typedParameters); } @Override public synchronized Long executeSql(final Query query) throws DatabaseException { final String queryString = query.getQueryString(); final List parameters = query.getParameters(); return _executeSql(queryString, parameters.toArray(new TypedParameter[0])); } @Override public synchronized List query(final String query, final String[] parameters) throws DatabaseException { final TypedParameter[] typedParameters = _stringArrayToTypedParameters(parameters); return _query(query, typedParameters); } @Override public synchronized List query(final Query query) throws DatabaseException { final String queryString = query.getQueryString(); final List parameters = query.getParameters(); return _query(queryString, parameters.toArray(new TypedParameter[0])); } @Override public Connection getRawConnection() { return _connection; } @Override public void close() throws DatabaseException { try { _connection.close(); } catch (final SQLException exception) { throw new DatabaseException("Unable to close database connection.", exception); } } }java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/JdbcDatabaseConnectionFactory.java000066400000000000000000000005561504445564400323050ustar00rootroot00000000000000package com.softwareverde.database.jdbc; import com.softwareverde.database.DatabaseConnectionFactory; import com.softwareverde.database.DatabaseException; import java.sql.Connection; public interface JdbcDatabaseConnectionFactory extends DatabaseConnectionFactory { @Override JdbcDatabaseConnection newConnection() throws DatabaseException; } java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/JdbcDatabaseProperties.java000066400000000000000000000003731504445564400310070ustar00rootroot00000000000000package com.softwareverde.database.jdbc; import com.softwareverde.database.properties.DatabaseProperties; import java.util.Properties; public interface JdbcDatabaseProperties extends DatabaseProperties { Properties getConnectionProperties(); } java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/row/000077500000000000000000000000001504445564400244045ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/row/JdbcRow.java000066400000000000000000000134521504445564400266060ustar00rootroot00000000000000package com.softwareverde.database.jdbc.row; import com.softwareverde.database.query.parameter.ParameterType; import com.softwareverde.database.query.parameter.TypedParameter; import com.softwareverde.database.row.Row; import com.softwareverde.util.Util; import java.nio.charset.Charset; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class JdbcRow implements Row { public static final String STRING_ENCODING = "ISO-8859-1"; protected static final Charset CHARSET; static { Charset charset; try { charset = Charset.forName(STRING_ENCODING); } catch (final Exception exception) { charset = Charset.defaultCharset(); } CHARSET = charset; } protected final List _orderedColumnNames; protected final Map _columnValues; protected JdbcRow() { _orderedColumnNames = new ArrayList(); _columnValues = new HashMap(); } /** * Consumes the internal values of the provided jdbcRow. */ protected JdbcRow(final JdbcRow jdbcRow) { _orderedColumnNames = jdbcRow._orderedColumnNames; _columnValues = jdbcRow._columnValues; } protected TypedParameter _getValue(final String columnName) throws IllegalArgumentException { final String lowerCaseColumnName = columnName.toLowerCase(); if (! _columnValues.containsKey(lowerCaseColumnName)) { throw new IllegalArgumentException("Row does not contain column: "+ columnName); } return _columnValues.get(lowerCaseColumnName); } protected String _getString(final String columnName) { final TypedParameter value = _getValue(columnName); if (value.value == null) { return null; } if (value.type == ParameterType.BYTE_ARRAY) { return new String((byte[]) value.value, CHARSET); } else if (value.type != ParameterType.STRING) { return value.value.toString(); } return (String) value.value; } protected Long _getWholeNumber(final String columnName) { final TypedParameter value = _getValue(columnName); if (value.value == null) { return null; } if (value.type == ParameterType.WHOLE_NUMBER) { return ((Long) value.value); } else if (value.type == ParameterType.FLOATING_POINT_NUMBER) { return ((Double) value.value).longValue(); } else { final String stringValue = _getString(columnName); return Util.parseLong(stringValue); } } protected Double _getFloatingPointNumber(final String columnName) { final TypedParameter value = _getValue(columnName); if (value.value == null) { return null; } if (value.type == ParameterType.FLOATING_POINT_NUMBER) { return ((Double) value.value); } else if (value.type == ParameterType.WHOLE_NUMBER) { return ((Long) value.value).doubleValue(); } else { final String stringValue = _getString(columnName); return Util.parseDouble(stringValue); } } /** * Returns the column names in order. */ @Override public List getColumnNames() { return new ArrayList(_orderedColumnNames); } @Override public String getString(final String columnName) { return _getString(columnName); } @Override public Integer getInteger(final String columnName) { final Long value = _getWholeNumber(columnName); if (value == null) { return null; } return value.intValue(); } @Override public Long getLong(final String columnName) { return _getWholeNumber(columnName); } @Override public Float getFloat(final String columnName) { final Double value = _getFloatingPointNumber(columnName); if (value == null) { return null; } return value.floatValue(); } @Override public Double getDouble(final String columnName) { return _getFloatingPointNumber(columnName); } @Override public Boolean getBoolean(final String columnName) { final Long value = _getWholeNumber(columnName); if (value == null) { return null; } return (value > 0L); } @Override public byte[] getBytes(final String columnName) { final TypedParameter value = _getValue(columnName); if (value.type != ParameterType.BYTE_ARRAY) { final String stringValue = _getString(columnName); if (stringValue == null) { return null; } return stringValue.getBytes(CHARSET); } return (byte[]) value.value; } @Override public LocalDate getDate(String columnName) { final TypedParameter value = _getValue(columnName); if (value.value == null) { return null; } if (value.type == ParameterType.DATETIME) { final LocalDateTime dateTime = (LocalDateTime) value.value; return dateTime.toLocalDate(); } return (LocalDate) value.value; } @Override public LocalTime getTime(String columnName) { final TypedParameter value = _getValue(columnName); if (value.value == null) { return null; } if (value.type == ParameterType.DATETIME) { final LocalDateTime dateTime = (LocalDateTime) value.value; return dateTime.toLocalTime(); } return (LocalTime) value.value; } @Override public LocalDateTime getDateTime(String columnName) { final TypedParameter value = _getValue(columnName); return (LocalDateTime) value.value; } } java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/row/JdbcRowFactory.java000066400000000000000000000130071504445564400301320ustar00rootroot00000000000000package com.softwareverde.database.jdbc.row; import com.softwareverde.database.DatabaseException; import com.softwareverde.database.query.parameter.TypedParameter; import com.softwareverde.database.row.RowFactory; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.sql.Types; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; public class JdbcRowFactory implements RowFactory { protected static Boolean isDateType(final Integer sqlDataType) { return sqlDataType == Types.DATE; } protected static Boolean isTimeType(final Integer sqlDataType) { switch (sqlDataType) { case Types.TIME: case Types.TIME_WITH_TIMEZONE: { return true; } default: { return false; } } } protected static Boolean isDateTimeType(final Integer sqlDataType) { switch (sqlDataType) { case Types.TIMESTAMP: case Types.TIMESTAMP_WITH_TIMEZONE: { return true; } default: { return false; } } } protected static Boolean isBinaryType(final Integer sqlDataType) { switch (sqlDataType) { case Types.BLOB: case Types.BINARY: case Types.VARBINARY: case Types.LONGVARBINARY: { return true; } default: { return false; } } } // NOTE: Types.ROWID is intentionally treated as a String... protected static Boolean isWholeNumberType(final Integer sqlDataType) { switch (sqlDataType) { case Types.BIGINT: case Types.INTEGER: case Types.SMALLINT: case Types.TINYINT: case Types.BOOLEAN: case Types.BIT: { return true; } default: { return false; } } } // NOTE: Types.NUMERIC and Types.DECIMAL are fixed-precision types, and are therefore stored internally as strings in order to maintain the precision... protected static Boolean isFloatingPointNumberType(final Integer sqlDataType) { switch (sqlDataType) { case Types.FLOAT: case Types.DOUBLE: case Types.REAL: { return true; } default: { return false; } } } public JdbcRow fromResultSet(final ResultSet resultSet) throws DatabaseException { final JdbcRow jdbcRow = new JdbcRow(); try { final ResultSetMetaData metaData = resultSet.getMetaData(); for (int i = 0; i < metaData.getColumnCount(); ++i) { final int columnIndex = (i + 1); final Integer sqlDataType = metaData.getColumnType(columnIndex); final String columnName = metaData.getColumnLabel(columnIndex).toLowerCase(); final TypedParameter typedValue; { if (JdbcRowFactory.isWholeNumberType(sqlDataType)) { final long longValue = resultSet.getLong(columnIndex); // NOTE: ResultSet::getLong returns 0L if null. Must use ResultSet::wasNull. final boolean wasNull = resultSet.wasNull(); typedValue = (wasNull ? TypedParameter.NULL : new TypedParameter(longValue)); } else if (JdbcRowFactory.isBinaryType(sqlDataType)) { final byte[] bytes = resultSet.getBytes(columnIndex); typedValue = ((bytes == null) ? TypedParameter.NULL : new TypedParameter(bytes)); } else if (JdbcRowFactory.isFloatingPointNumberType(sqlDataType)) { final double doubleValue = resultSet.getDouble(columnIndex); // NOTE: ResultSet::getDouble returns 0D if null. Must use ResultSet::wasNull. final boolean wasNull = resultSet.wasNull(); typedValue = (wasNull ? TypedParameter.NULL : new TypedParameter(doubleValue)); } else if (JdbcRowFactory.isDateType(sqlDataType)) { final LocalDate date = resultSet.getObject(columnIndex, java.time.LocalDate.class); typedValue = ((date == null) ? TypedParameter.NULL : new TypedParameter(date)); } else if (JdbcRowFactory.isTimeType(sqlDataType)) { final LocalTime time = resultSet.getObject(columnIndex, java.time.LocalTime.class); typedValue = ((time == null) ? TypedParameter.NULL : new TypedParameter(time)); } else if (JdbcRowFactory.isDateTimeType(sqlDataType)) { final LocalDateTime datetime = resultSet.getObject(columnIndex, java.time.LocalDateTime.class); typedValue = ((datetime == null) ? TypedParameter.NULL : new TypedParameter(datetime)); } else { final String stringValue = resultSet.getString(columnIndex); typedValue = ((stringValue == null) ? TypedParameter.NULL : new TypedParameter(stringValue)); } } jdbcRow._orderedColumnNames.add(columnName); jdbcRow._columnValues.put(columnName, typedValue); } } catch (final SQLException exception) { throw new DatabaseException(exception); } return jdbcRow; } } java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/transaction/000077500000000000000000000000001504445564400261225ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/transaction/DatabaseCallable.java000066400000000000000000000005171504445564400321140ustar00rootroot00000000000000package com.softwareverde.database.jdbc.transaction; import com.softwareverde.database.DatabaseConnection; import com.softwareverde.database.DatabaseException; public interface DatabaseCallable { ReturnType call(final DatabaseConnection databaseConnection) throws DatabaseException; } java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/transaction/DatabaseRunnable.java000066400000000000000000000004421504445564400321600ustar00rootroot00000000000000package com.softwareverde.database.jdbc.transaction; import com.softwareverde.database.DatabaseConnection; import com.softwareverde.database.DatabaseException; public interface DatabaseRunnable { void run(final DatabaseConnection databaseConnection) throws DatabaseException; } java-db-3.4.0/src/main/java/com/softwareverde/database/jdbc/transaction/JdbcDatabaseTransaction.java000066400000000000000000000045531504445564400334710ustar00rootroot00000000000000package com.softwareverde.database.jdbc.transaction; import com.softwareverde.database.DatabaseConnection; import com.softwareverde.database.DatabaseConnectionFactory; import com.softwareverde.database.DatabaseException; import com.softwareverde.database.transaction.DatabaseTransaction; import java.sql.Connection; import java.sql.SQLException; public class JdbcDatabaseTransaction implements DatabaseTransaction { protected final DatabaseConnectionFactory _databaseConnectionFactory; public JdbcDatabaseTransaction(final DatabaseConnectionFactory databaseConnectionFactory) { _databaseConnectionFactory = databaseConnectionFactory; } @Override public void execute(final DatabaseRunnable databaseConnectedRunnable) throws DatabaseException { try (final DatabaseConnection databaseConnection = _databaseConnectionFactory.newConnection()) { final Connection connection = databaseConnection.getRawConnection(); // Should be closed for us by DatabaseConnection.close() try { connection.setAutoCommit(false); databaseConnectedRunnable.run(databaseConnection); connection.commit(); } catch (final Exception exception) { connection.rollback(); throw exception; } } catch (final Exception exception) { throw new DatabaseException("Unable to complete query.", exception); } } @Override public T call(final DatabaseCallable databaseConnectedCallable) throws DatabaseException { try (final DatabaseConnection databaseConnection = _databaseConnectionFactory.newConnection()) { final Connection connection = databaseConnection.getRawConnection(); try { connection.setAutoCommit(false); final T returnValue = databaseConnectedCallable.call(databaseConnection); connection.commit(); return returnValue; } catch (final SQLException exception) { connection.rollback(); throw exception; } } catch (final Exception exception) { throw new DatabaseException("Unable to complete query.", exception); } } }java-db-3.4.0/src/main/java/com/softwareverde/database/properties/000077500000000000000000000000001504445564400250675ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/database/properties/DatabaseCredentials.java000066400000000000000000000004631504445564400316170ustar00rootroot00000000000000package com.softwareverde.database.properties; public class DatabaseCredentials { public final String username; public final String password; public DatabaseCredentials(final String username, final String password) { this.username = username; this.password = password; } } java-db-3.4.0/src/main/java/com/softwareverde/database/properties/DatabaseProperties.java000066400000000000000000000005141504445564400315130ustar00rootroot00000000000000package com.softwareverde.database.properties; public interface DatabaseProperties { String getRootPassword(); String getHostname(); String getUsername(); String getPassword(); String getSchema(); Integer getPort(); DatabaseCredentials getRootCredentials(); DatabaseCredentials getCredentials(); } java-db-3.4.0/src/main/java/com/softwareverde/database/properties/MutableDatabaseProperties.java000066400000000000000000000035621504445564400330330ustar00rootroot00000000000000package com.softwareverde.database.properties; public class MutableDatabaseProperties implements DatabaseProperties { protected String _rootPassword; protected String _hostname; protected String _username; protected String _password; protected String _schema; protected Integer _port; public MutableDatabaseProperties() { } public MutableDatabaseProperties(final DatabaseProperties databaseProperties) { _rootPassword = databaseProperties.getRootPassword(); _hostname = databaseProperties.getHostname(); _username = databaseProperties.getUsername(); _password = databaseProperties.getPassword(); _schema = databaseProperties.getSchema(); _port = databaseProperties.getPort(); } @Override public String getRootPassword() { return _rootPassword; } @Override public String getHostname() { return _hostname; } @Override public String getUsername() { return _username; } @Override public String getPassword() { return _password; } @Override public String getSchema() { return _schema; } @Override public Integer getPort() { return _port; } @Override public DatabaseCredentials getRootCredentials() { return new DatabaseCredentials("root", _rootPassword); } @Override public DatabaseCredentials getCredentials() { return new DatabaseCredentials(_username, _password); } public void setRootPassword(final String rootPassword) { _rootPassword = rootPassword; } public void setHostname(final String hostname) { _hostname = hostname; } public void setUsername(final String username) { _username = username; } public void setPassword(final String password) { _password = password; } public void setSchema(final String schema) { _schema = schema; } public void setPort(final Integer port) { _port = port; } } java-db-3.4.0/src/main/java/com/softwareverde/database/query/000077500000000000000000000000001504445564400240405ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/database/query/BatchedInsertQuery.java000066400000000000000000000110271504445564400304510ustar00rootroot00000000000000package com.softwareverde.database.query; import com.softwareverde.database.query.parameter.ParameterFactory; import java.util.HashMap; import java.util.concurrent.locks.ReentrantReadWriteLock; import java.util.regex.Pattern; public class BatchedInsertQuery extends Query { protected static final HashMap PARAMETER_MATCHERS = new HashMap(); protected static ReentrantReadWriteLock.ReadLock PARAMETER_MATCHER_READ_LOCK; protected static ReentrantReadWriteLock.WriteLock PARAMETER_MATCHER_WRITE_LOCK; static { final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(); PARAMETER_MATCHER_READ_LOCK = readWriteLock.readLock(); PARAMETER_MATCHER_WRITE_LOCK = readWriteLock.writeLock(); } protected static Pattern buildMatcher(final Integer parameterCount) { final String parameterMatchString; { final StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append("("); String separator = ""; for (int i = 0; i < parameterCount; ++i) { stringBuilder.append(separator); stringBuilder.append("\\?"); separator = ",[ ]*"; } stringBuilder.append(")"); parameterMatchString = stringBuilder.toString(); } return Pattern.compile(parameterMatchString); } protected static Pattern getMatcher(final Integer parameterCount) { if (parameterCount > 64) { // Do not cache inserts with columns greater than 64 entries. // This limit is fairly arbitrary and only intended to handle forever-caching unpredicted one-off queries with large column counts. return BatchedInsertQuery.buildMatcher(parameterCount); } PARAMETER_MATCHER_READ_LOCK.lock(); try { final Pattern pattern = PARAMETER_MATCHERS.get(parameterCount); if (pattern != null) { return pattern; } } finally { PARAMETER_MATCHER_READ_LOCK.unlock(); } PARAMETER_MATCHER_WRITE_LOCK.lock(); try { final Pattern pattern = BatchedInsertQuery.buildMatcher(parameterCount); PARAMETER_MATCHERS.put(parameterCount, pattern); return pattern; } finally { PARAMETER_MATCHER_WRITE_LOCK.unlock(); } } protected BatchedInsertQuery(final Query query, final Boolean shouldConsumeQuery, final ParameterFactory parameterFactory) { super(query, shouldConsumeQuery, parameterFactory); } public BatchedInsertQuery(final String query) { super(query); } public BatchedInsertQuery(final Query query) { super(query); } @Override public String getQueryString() { final int parameterCount = _parameters.getCount(); final int parameterCountPerBatch = (_query.length() - _query.replace("?", "").length()); final int batchCount = (parameterCount / parameterCountPerBatch); if ( (batchCount > 0) && ((parameterCount % parameterCountPerBatch) != 0) ) { throw new RuntimeException("Invalid parameter count for batched query: " + _query); } final int firstParamParenthesisIndex; final int lastParamParenthesisIndex; { final int firstParamIndex = _query.indexOf('?'); final int lastParamIndex = _query.lastIndexOf('?'); { int index = (firstParamIndex - 1); while (_query.charAt(index) != '(') { index -= 1; } firstParamParenthesisIndex = index; } { int index = (lastParamIndex + 1); while (_query.charAt(index) != ')') { index += 1; } lastParamParenthesisIndex = index; } } final StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append(_query, 0, firstParamParenthesisIndex); String delimiter = ""; final String parameterList = _query.substring(firstParamParenthesisIndex, (lastParamParenthesisIndex + 1)); for (int i = 0; i < batchCount; ++i) { stringBuilder.append(delimiter); stringBuilder.append(parameterList); delimiter = ", "; } stringBuilder.append(_query.substring(lastParamParenthesisIndex + 1)); return stringBuilder.toString(); } public void clear() { _parameters.clear(); } } java-db-3.4.0/src/main/java/com/softwareverde/database/query/BatchedUpdateQuery.java000066400000000000000000000040731504445564400304320ustar00rootroot00000000000000package com.softwareverde.database.query; import com.softwareverde.database.query.parameter.ParameterFactory; import java.util.regex.Matcher; import java.util.regex.Pattern; public class BatchedUpdateQuery extends Query { protected BatchedUpdateQuery(final Query query, final Boolean shouldConsumeQuery, final ParameterFactory parameterFactory) { super(query, shouldConsumeQuery, parameterFactory); } public BatchedUpdateQuery(final String query) { super(query); } public BatchedUpdateQuery(final Query query) { super(query); } @Override public String getQueryString() { // UPDATE t SET v = x WHERE z IN (?) final Integer parameterCount = _parameters.getCount(); final Integer nonInClauseParameterCount = (_query.length() - _query.replace("?", "").length()) - 1; final int batchCount = (parameterCount - nonInClauseParameterCount); if (nonInClauseParameterCount < 0) { throw new RuntimeException("Invalid parameter count for batched update query: " + _query); } final String queryStart; final String queryEnd; { final Matcher matcher = Pattern.compile("IN[ ]*\\(\\?\\)").matcher(_query); if (! matcher.find()) { throw new RuntimeException("Could not find IN clause for query: " + _query); } final int startIndex = matcher.start(); final int endIndex = matcher.end(); queryStart = _query.substring(0, startIndex); queryEnd = _query.substring(endIndex); } final StringBuilder stringBuilder = new StringBuilder(queryStart); stringBuilder.append("IN ("); for (int i = 0; i < batchCount; ++i) { stringBuilder.append("?"); if (i < batchCount - 1) { stringBuilder.append(", "); } } stringBuilder.append(")"); stringBuilder.append(queryEnd); return stringBuilder.toString(); } public void clear() { _parameters.clear(); } } java-db-3.4.0/src/main/java/com/softwareverde/database/query/ParameterFactoryCore.java000066400000000000000000000046051504445564400307710ustar00rootroot00000000000000package com.softwareverde.database.query; import com.softwareverde.constable.bytearray.ByteArray; import com.softwareverde.database.query.parameter.ParameterFactory; import com.softwareverde.database.query.parameter.TypedParameter; import com.softwareverde.util.type.identifier.Identifier; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; public class ParameterFactoryCore implements ParameterFactory { @Override public TypedParameter fromObject(final Object object) { if (object == null) { return TypedParameter.NULL; } if (object instanceof Boolean) { return new TypedParameter((Boolean) object); } else if (object instanceof Long) { return new TypedParameter((Long) object); } else if (object instanceof Integer) { return new TypedParameter((Integer) object); } else if (object instanceof Short) { return new TypedParameter((Short) object); } else if (object instanceof Double) { return new TypedParameter((Double) object); } else if (object instanceof Float) { return new TypedParameter((Float) object); } else if (object instanceof byte[]) { return new TypedParameter((byte[]) object); } else if (object instanceof ByteArray) { return new TypedParameter(((ByteArray) object).getBytes()); } else if (object instanceof Identifier) { return new TypedParameter(((Identifier) object).longValue()); } else if (object instanceof LocalDate) { return new TypedParameter((LocalDate) object); } else if (object instanceof LocalTime) { return new TypedParameter((LocalTime) object); } else if (object instanceof LocalDateTime) { return new TypedParameter((LocalDateTime) object); } else if (object instanceof TypedParameter) { return (TypedParameter) object; } else if (object instanceof String) { return new TypedParameter((String) object); } // Warning is not logged to facilitate class extension. // final Class objectClass = object.getClass(); // Logger.warn("Unknown Object for TypedParameter Factory: " + objectClass.getName()); return null; } } java-db-3.4.0/src/main/java/com/softwareverde/database/query/Query.java000066400000000000000000000366411504445564400260220ustar00rootroot00000000000000package com.softwareverde.database.query; import com.softwareverde.constable.bytearray.ByteArray; import com.softwareverde.constable.list.List; import com.softwareverde.constable.list.mutable.MutableArrayList; import com.softwareverde.constable.list.mutable.MutableList; import com.softwareverde.database.query.parameter.InClauseParameter; import com.softwareverde.database.query.parameter.ParameterFactory; import com.softwareverde.database.query.parameter.TypedParameter; import com.softwareverde.util.Util; import com.softwareverde.util.type.identifier.Identifier; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; import java.util.ArrayList; import java.util.regex.Matcher; import java.util.regex.Pattern; public class Query { public static final TypedParameter NULL = TypedParameter.NULL; public static final String NULL_STRING = "NULL"; public static final String TRUE_STRING = "TRUE"; protected static final Pattern IN_CLAUSE_PATTERN = Pattern.compile("((\\([^()]+\\))|(\\w+))? IN[ ]*\\(\\?\\)"); protected static final Pattern TUPLE_PATTERN = Pattern.compile("([^,()\\s]+)"); protected static class ExtendedInClauseParameters { public final List inClauseParameters; public final Boolean isExtendedInClause; public ExtendedInClauseParameters(final List inClauseParameters, final Boolean isExtendedInClause) { this.inClauseParameters = inClauseParameters; this.isExtendedInClause = isExtendedInClause; } } protected static StringBuilder buildParenthesisList(final Integer parameterCount) { final StringBuilder stringBuilder = new StringBuilder(); if (parameterCount > 0) { stringBuilder.append("("); String separator = ""; for (int i = 0; i < parameterCount; ++i) { stringBuilder.append(separator); stringBuilder.append("?"); separator = ","; } stringBuilder.append(")"); } else { stringBuilder.append(NULL_STRING); } return stringBuilder; } protected static String buildInClause(final List inClauseParameters) { final StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append("IN ("); if (inClauseParameters.getCount() > 0) { String separator = ""; for (final InClauseParameter inClauseParameter : inClauseParameters) { stringBuilder.append(separator); if (inClauseParameter.getType() == InClauseParameter.Type.TUPLE) { final Integer parameterCount = inClauseParameter.getParameterCount(); stringBuilder.append(Query.buildParenthesisList(parameterCount)); } else { stringBuilder.append("?"); } separator = ", "; } } else { stringBuilder.append(NULL_STRING); } stringBuilder.append(")"); return stringBuilder.toString(); } protected static String buildAndList(final List columnNames) { final StringBuilder stringBuilder = new StringBuilder(); String separator = ""; for (final String columnName : columnNames) { stringBuilder.append(separator); stringBuilder.append(columnName); stringBuilder.append(" = ?"); separator = " AND "; } return stringBuilder.toString(); } protected static String buildExpandedWhereInClause(final List columnNames, final Integer tupleCount) { if (tupleCount == 0) { return TRUE_STRING; } final StringBuilder stringBuilder = new StringBuilder(); String separator = ""; for (int i = 0; i < tupleCount; ++i) { stringBuilder.append(separator); stringBuilder.append("("); stringBuilder.append(Query.buildAndList(columnNames)); stringBuilder.append(")"); separator = " OR "; } return stringBuilder.toString(); } protected final String _query; protected final MutableList _parameters; protected final ParameterFactory _parameterFactory; protected final MutableList _inClauseParameters = new MutableArrayList<>(); protected final MutableList _inClauseParameterIndexes = new MutableArrayList(); protected Integer _nextParameterIndex = 0; protected void _setInClauseParameters(final InClauseParameter inClauseParameter, final InClauseParameter[] extraInClauseParameters, final Boolean enableExpandedInClause) { final MutableList valueTuples = new MutableArrayList((extraInClauseParameters != null ? extraInClauseParameters.length : 0) + 1); valueTuples.add(Util.coalesce(inClauseParameter, InClauseParameter.NULL)); if (extraInClauseParameters != null) { for (final InClauseParameter extraInClauseParameter : extraInClauseParameters) { valueTuples.add(extraInClauseParameter); } } _inClauseParameters.add(new ExtendedInClauseParameters(valueTuples, enableExpandedInClause)); _inClauseParameterIndexes.add(_nextParameterIndex); _nextParameterIndex += 1; } protected void _setInClauseParameters(final Iterable values, final ValueExtractor valueExtractor, final Boolean enableExpandedInClause) { final MutableList typedParameters = new MutableArrayList(); for (final T value : values) { final InClauseParameter inClauseParameter = valueExtractor.extractValues(value); typedParameters.add(Util.coalesce(inClauseParameter, InClauseParameter.NULL)); } _inClauseParameters.add(new ExtendedInClauseParameters(typedParameters, enableExpandedInClause)); _inClauseParameterIndexes.add(_nextParameterIndex); _nextParameterIndex += 1; } protected Query(final Query query, final Boolean shouldConsumeQuery, final ParameterFactory parameterFactory) { if (shouldConsumeQuery) { _query = query._query; _parameters = query._parameters; } else { _query = query._query; _parameters = new MutableArrayList(query._parameters); } _parameterFactory = parameterFactory; } protected Query(final String query, final ParameterFactory parameterFactory) { _query = query; _parameters = new MutableArrayList(); _parameterFactory = parameterFactory; } public Query(final Query query) { this(query, false, new ParameterFactoryCore()); } public Query(final String query) { _query = query; _parameters = new MutableArrayList(); _parameterFactory = new ParameterFactoryCore(); } public Query setParameter(final Boolean value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final Long value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final Integer value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final Short value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final Double value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final Float value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final byte[] value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final ByteArray value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final Identifier value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final TypedParameter value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final String value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final LocalDate value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final LocalTime value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setParameter(final LocalDateTime value) { final TypedParameter typedParameter = _parameterFactory.fromObject(value); _parameters.add(typedParameter); _nextParameterIndex += 1; return this; } public Query setNullParameter() { _parameters.add(NULL); _nextParameterIndex += 1; return this; } public Query setInClauseParameters(final InClauseParameter inClauseParameter, final InClauseParameter... extraInClauseParameters) { _setInClauseParameters(inClauseParameter, extraInClauseParameters, false); return this; } public Query setInClauseParameters(final Iterable values, final ValueExtractor valueExtractor) { _setInClauseParameters(values, valueExtractor, false); return this; } public Query setExpandedInClauseParameters(final InClauseParameter inClauseParameter, final InClauseParameter... extraInClauseParameters) { _setInClauseParameters(inClauseParameter, extraInClauseParameters, true); return this; } public Query setExpandedInClauseParameters(final Iterable values, final ValueExtractor valueExtractor) { _setInClauseParameters(values, valueExtractor, true); return this; } public String getQueryString() { final int inClauseCount = _inClauseParameters.getCount(); if (inClauseCount == 0) { return _query; } final Matcher matcher = Query.IN_CLAUSE_PATTERN.matcher(_query); final StringBuffer stringBuffer = new StringBuffer(); { int matchCount = 0; while (matcher.find()) { if (matchCount >= inClauseCount) { break; } final ExtendedInClauseParameters extendedInClauseParameters = _inClauseParameters.get(matchCount); final List inClauseParameters = extendedInClauseParameters.inClauseParameters; final Boolean useExpandedInClause = extendedInClauseParameters.isExtendedInClause; final String rawColumnNames = matcher.group(1); if (useExpandedInClause) { final Matcher columnNameMatcher = Query.TUPLE_PATTERN.matcher(rawColumnNames); final MutableList columnNames = new MutableArrayList(); while (columnNameMatcher.find()) { final String columnName = columnNameMatcher.group(1); columnNames.add(columnName); } final String inClause = "(" + Query.buildExpandedWhereInClause(columnNames, inClauseParameters.getCount()) + ")"; matcher.appendReplacement(stringBuffer, inClause); } else { final String inClause = Query.buildInClause(inClauseParameters); matcher.appendReplacement(stringBuffer, (rawColumnNames + " " + inClause)); } matchCount += 1; } matcher.appendTail(stringBuffer); if (matchCount != inClauseCount) { throw new RuntimeException("In Clause parameter mismatch. Expected " + matchCount + " found " + inClauseCount + "."); } } return stringBuffer.toString(); } public java.util.List getParameters() { if (_inClauseParameters.isEmpty()) { final java.util.List parameters = new ArrayList(_parameters.getCount()); for (final TypedParameter typedParameter : _parameters) { parameters.add(typedParameter); } return parameters; } final java.util.List parameters = new ArrayList(); final int inClauseCount = _inClauseParameters.getCount(); int inClauseIndex = 0; int nextInClauseParameterIndex = _inClauseParameterIndexes.get(inClauseIndex); int returnedParameterIndex = 0; int parameterIndex = 0; final int loopCount = (_parameters.getCount() + inClauseCount); for (int i = 0; i < loopCount; ++i) { if (nextInClauseParameterIndex == returnedParameterIndex) { final ExtendedInClauseParameters extendedInClauseParameters = _inClauseParameters.get(inClauseIndex); for (final InClauseParameter inClauseParameter : extendedInClauseParameters.inClauseParameters) { if (inClauseParameter.getType() == InClauseParameter.Type.NULL) { parameters.add(TypedParameter.NULL); } else { for (final TypedParameter typedParameter : inClauseParameter.getParameters()) { parameters.add(typedParameter); } } } inClauseIndex += 1; nextInClauseParameterIndex = (inClauseIndex < inClauseCount ? _inClauseParameterIndexes.get(inClauseIndex) : -1); } else { final TypedParameter parameter = _parameters.get(parameterIndex); parameters.add(parameter); parameterIndex += 1; } returnedParameterIndex += 1; } return parameters; } } java-db-3.4.0/src/main/java/com/softwareverde/database/query/ValueExtractor.java000066400000000000000000000057341504445564400276640ustar00rootroot00000000000000package com.softwareverde.database.query; import com.softwareverde.database.query.parameter.InClauseParameter; import com.softwareverde.database.query.parameter.TypedParameter; public interface ValueExtractor { ValueExtractor BOOLEAN = new ValueExtractor() { @Override public InClauseParameter extractValues(final Boolean value) { final TypedParameter typedParameter = (value != null ? new TypedParameter(value) : TypedParameter.NULL); return new InClauseParameter(typedParameter); } }; ValueExtractor STRING = new ValueExtractor() { @Override public InClauseParameter extractValues(final String value) { final TypedParameter typedParameter = (value != null ? new TypedParameter(value) : TypedParameter.NULL); return new InClauseParameter(typedParameter); } }; ValueExtractor INTEGER = new ValueExtractor() { @Override public InClauseParameter extractValues(final Integer value) { final TypedParameter typedParameter = (value != null ? new TypedParameter(value) : TypedParameter.NULL); return new InClauseParameter(typedParameter); } }; ValueExtractor LONG = new ValueExtractor() { @Override public InClauseParameter extractValues(final Long value) { final TypedParameter typedParameter = (value != null ? new TypedParameter(value) : TypedParameter.NULL); return new InClauseParameter(typedParameter); } }; ValueExtractor SHORT = new ValueExtractor() { @Override public InClauseParameter extractValues(final Short value) { final TypedParameter typedParameter = (value != null ? new TypedParameter(value) : TypedParameter.NULL); return new InClauseParameter(typedParameter); } }; ValueExtractor FLOAT = new ValueExtractor() { @Override public InClauseParameter extractValues(final Float value) { final TypedParameter typedParameter = (value != null ? new TypedParameter(value) : TypedParameter.NULL); return new InClauseParameter(typedParameter); } }; ValueExtractor DOUBLE = new ValueExtractor() { @Override public InClauseParameter extractValues(final Double value) { final TypedParameter typedParameter = (value != null ? new TypedParameter(value) : TypedParameter.NULL); return new InClauseParameter(typedParameter); } }; ValueExtractor BYTE_ARRAY = new ValueExtractor() { @Override public InClauseParameter extractValues(final byte[] value) { final TypedParameter typedParameter = (value != null ? new TypedParameter(value) : TypedParameter.NULL); return new InClauseParameter(typedParameter); } }; InClauseParameter extractValues(T value); } java-db-3.4.0/src/main/java/com/softwareverde/database/query/parameter/000077500000000000000000000000001504445564400260205ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/database/query/parameter/InClauseParameter.java000066400000000000000000000031251504445564400322300ustar00rootroot00000000000000package com.softwareverde.database.query.parameter; import com.softwareverde.constable.list.List; import com.softwareverde.constable.list.immutable.ImmutableListBuilder; public class InClauseParameter { public static final InClauseParameter NULL = new InClauseParameter(); public enum Type { NULL, SINGLE, TUPLE } protected final Type _type; protected final List _parameters; public InClauseParameter(final TypedParameter... typedParameters) { if ( (typedParameters == null) || (typedParameters.length == 0) ) { _type = Type.NULL; _parameters = (new ImmutableListBuilder(0)).build(); } else { _type = (typedParameters.length == 1 ? Type.SINGLE : Type.TUPLE); final ImmutableListBuilder typedParameterListBuilder = new ImmutableListBuilder(typedParameters.length); for (final TypedParameter typedParameter : typedParameters) { typedParameterListBuilder.add(typedParameter); } _parameters = typedParameterListBuilder.build(); } } public Type getType() { return _type; } public Integer getParameterCount() { return _parameters.getCount(); } public TypedParameter getParameter() { if (_type != Type.SINGLE) { throw new RuntimeException("Attempted to get single parameter of tuple type."); } return _parameters.get(0); } public List getParameters() { return _parameters; } } java-db-3.4.0/src/main/java/com/softwareverde/database/query/parameter/ParameterFactory.java000066400000000000000000000002111504445564400321250ustar00rootroot00000000000000package com.softwareverde.database.query.parameter; public interface ParameterFactory { TypedParameter fromObject(Object object); } java-db-3.4.0/src/main/java/com/softwareverde/database/query/parameter/ParameterType.java000066400000000000000000000002451504445564400314460ustar00rootroot00000000000000package com.softwareverde.database.query.parameter; public enum ParameterType { BYTE_ARRAY, STRING, WHOLE_NUMBER, FLOATING_POINT_NUMBER, DATE, TIME, DATETIME } java-db-3.4.0/src/main/java/com/softwareverde/database/query/parameter/TypedParameter.java000066400000000000000000000062231504445564400316140ustar00rootroot00000000000000package com.softwareverde.database.query.parameter; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; public class TypedParameter { /** * Provided only for efficiency so a new TypedParameter doesn't have to be created for a null value. * Typically, the types for a null value have little meaning, so only one instance is provided. */ public static final TypedParameter NULL = new TypedParameter(); protected static final Long TRUE = 1L; protected static final Long FALSE = 0L; public final ParameterType type; public final Object value; protected TypedParameter() { this.type = ParameterType.STRING; this.value = null; } /** * Creates a Boolean TypedParameter. The value may be null. */ public TypedParameter(final Boolean value) { this.type = ParameterType.WHOLE_NUMBER; this.value = (value != null ? (value ? TRUE : FALSE) : null); } /** * Creates a String TypedParameter. The value may be null. */ public TypedParameter(final String value) { this.type = ParameterType.STRING; this.value = value; } /** * Creates a Long TypedParameter. The value may be null. */ public TypedParameter(final Long value) { this.type = ParameterType.WHOLE_NUMBER; this.value = value; } /** * Creates an Integer TypedParameter. The value may be null. */ public TypedParameter(final Integer value) { this.type = ParameterType.WHOLE_NUMBER; this.value = (value != null ? value.longValue() : null); } /** * Creates a Short TypedParameter. The value may be null. */ public TypedParameter(final Short value) { this.type = ParameterType.WHOLE_NUMBER; this.value = (value != null ? value.longValue() : null); } /** * Creates a Double TypedParameter. The value may be null. */ public TypedParameter(final Double value) { this.type = ParameterType.FLOATING_POINT_NUMBER; this.value = value; } /** * Creates a Float TypedParameter. The value may be null. */ public TypedParameter(final Float value) { this.type = ParameterType.FLOATING_POINT_NUMBER; this.value = (value != null ? value.doubleValue() : null); } /** * Creates a byte[] TypedParameter. The value may be null. */ public TypedParameter(final byte[] value) { this.type = ParameterType.BYTE_ARRAY; this.value = value; } /** * Creates a LocalDate TypedParameter. The value may be null. */ public TypedParameter(final LocalDate value) { this.type = ParameterType.DATE; this.value = value; } /** * Creates a LocalTime TypedParameter. The value may be null. */ public TypedParameter(final LocalTime value) { this.type = ParameterType.TIME; this.value = value; } /** * Creates a LocalDateTime TypedParameter. The value may be null. */ public TypedParameter(final LocalDateTime value) { this.type = ParameterType.DATETIME; this.value = value; } } java-db-3.4.0/src/main/java/com/softwareverde/database/row/000077500000000000000000000000001504445564400235025ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/database/row/Row.java000066400000000000000000000011701504445564400251130ustar00rootroot00000000000000package com.softwareverde.database.row; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; import java.util.List; public interface Row { List getColumnNames(); String getString(String columnName); Integer getInteger(String columnName); Long getLong(String columnName); Float getFloat(String columnName); Double getDouble(String columnName); Boolean getBoolean(String columnName); byte[] getBytes(String columnName); LocalDate getDate(String columnName); LocalTime getTime(String columnName); LocalDateTime getDateTime(String columnName); } java-db-3.4.0/src/main/java/com/softwareverde/database/row/RowFactory.java000066400000000000000000000003461504445564400264470ustar00rootroot00000000000000package com.softwareverde.database.row; import com.softwareverde.database.DatabaseException; import java.sql.ResultSet; public interface RowFactory { Row fromResultSet(final ResultSet resultSet) throws DatabaseException; } java-db-3.4.0/src/main/java/com/softwareverde/database/transaction/000077500000000000000000000000001504445564400252205ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/database/transaction/DatabaseTransaction.java000066400000000000000000000010161504445564400317730ustar00rootroot00000000000000package com.softwareverde.database.transaction; import com.softwareverde.database.DatabaseException; import com.softwareverde.database.jdbc.transaction.DatabaseCallable; import com.softwareverde.database.jdbc.transaction.DatabaseRunnable; public interface DatabaseTransaction { void execute(final DatabaseRunnable databaseRunnable) throws DatabaseException; ReturnType call(final DatabaseCallable databaseCallable) throws DatabaseException; } java-db-3.4.0/src/main/java/com/softwareverde/database/util/000077500000000000000000000000001504445564400236505ustar00rootroot00000000000000java-db-3.4.0/src/main/java/com/softwareverde/database/util/DatabaseUtil.java000066400000000000000000000045201504445564400270560ustar00rootroot00000000000000package com.softwareverde.database.util; import com.softwareverde.constable.list.List; import com.softwareverde.constable.list.immutable.ImmutableListBuilder; import java.util.Map; public class DatabaseUtil { protected DatabaseUtil() { } // protected static String _createInClause(final Iterable list, final Map keyMap) { // final StringBuilder stringBuilder = new StringBuilder(); // // String prefix = ""; // for (final T item : list) { // stringBuilder.append(prefix); // stringBuilder.append("'"); // stringBuilder.append(item); // stringBuilder.append("'"); // prefix = ","; // // if (keyMap != null) { // keyMap.put(item, null); // } // } // // return stringBuilder.toString(); // } // /** // * Creates a concatenated string for use within SQL "in" clauses. // * e.g. SELECT id FROM table WHERE value IN (?) // * NOTE: The order of the rows returned are NOT guaranteed to be in the same order as the provided list. // * Instead, consider using DatabaseUtil::createInClause(List, Map) in conjunction with DatabaseUtil::sortMappedRows(List, List, Map). // */ // public static String createInClause(final List list) { // if (list.isEmpty()) { return "NULL"; } // return _createInClause(list, null); // } // // public static String createInClause(final Collection list) { // if (list.isEmpty()) { return "NULL"; } // return _createInClause(list, null); // } // // public static String createInClause(final List list, final Map keyMap) { // if (list.isEmpty()) { return "NULL"; } // return _createInClause(list, keyMap); // } // // public static String createInClause(final Collection list, final Map keyMap) { // if (list.isEmpty()) { return "NULL"; } // return _createInClause(list, keyMap); // } public static List sortMappedRows(final List rowOrder, final Map keyMap) { final ImmutableListBuilder lockingScriptsBuilder = new ImmutableListBuilder(); for (final T key : rowOrder) { final V value = keyMap.get(key); lockingScriptsBuilder.add(value); } return lockingScriptsBuilder.build(); } } java-db-3.4.0/src/main/java/com/softwareverde/database/util/TransactionUtil.java000066400000000000000000000026721504445564400276450ustar00rootroot00000000000000package com.softwareverde.database.util; import com.softwareverde.database.DatabaseConnection; import com.softwareverde.database.DatabaseException; import java.sql.Connection; public class TransactionUtil { public static void startTransaction(final DatabaseConnection databaseConnection) throws DatabaseException { try { final Connection rawConnection = databaseConnection.getRawConnection(); rawConnection.setAutoCommit(false); } catch (final Exception exception) { throw new DatabaseException(exception); } } public static void commitTransaction(final DatabaseConnection databaseConnection) throws DatabaseException { try { final Connection rawConnection = databaseConnection.getRawConnection(); rawConnection.commit(); rawConnection.setAutoCommit(true); } catch (final Exception exception) { throw new DatabaseException(exception); } } public static void rollbackTransaction(final DatabaseConnection databaseConnection) throws DatabaseException { try { final Connection rawConnection = databaseConnection.getRawConnection(); rawConnection.rollback(); rawConnection.setAutoCommit(true); } catch (final Exception exception) { throw new DatabaseException(exception); } } } java-db-3.4.0/src/test/000077500000000000000000000000001504445564400146035ustar00rootroot00000000000000java-db-3.4.0/src/test/java/000077500000000000000000000000001504445564400155245ustar00rootroot00000000000000java-db-3.4.0/src/test/java/com/000077500000000000000000000000001504445564400163025ustar00rootroot00000000000000java-db-3.4.0/src/test/java/com/softwareverde/000077500000000000000000000000001504445564400211625ustar00rootroot00000000000000java-db-3.4.0/src/test/java/com/softwareverde/database/000077500000000000000000000000001504445564400227265ustar00rootroot00000000000000java-db-3.4.0/src/test/java/com/softwareverde/database/QueryTests.java000066400000000000000000000374361504445564400257360ustar00rootroot00000000000000package com.softwareverde.database; import com.softwareverde.constable.list.mutable.MutableArrayList; import com.softwareverde.constable.list.mutable.MutableList; import com.softwareverde.database.query.Query; import com.softwareverde.database.query.ValueExtractor; import com.softwareverde.database.query.parameter.InClauseParameter; import com.softwareverde.database.query.parameter.ParameterType; import com.softwareverde.database.query.parameter.TypedParameter; import com.softwareverde.util.Tuple; import org.junit.Assert; import org.junit.Test; import java.util.ArrayList; import java.util.List; public class QueryTests { @Test public void should_add_multiple_parameter_types_to_query() { // Setup final Query query = new Query("SELECT ?, ?, ?, ?, ?, ?"); final Boolean booleanObject = true; final Integer integerObject = -2; final Float floatObject = 7.777F; // Action query.setParameter(true); // 0 query.setParameter(booleanObject); // 1 query.setParameter("String"); // 2 query.setParameter(2); // 3 query.setParameter(integerObject); // 4 query.setParameter(new byte[] { 0x00, 0x01 }); // 5 query.setParameter(floatObject); // 6 query.setParameter(7F); // 7 // Assert final List parameterValues = query.getParameters(); Assert.assertEquals(1L, parameterValues.get(0).value); Assert.assertEquals(ParameterType.WHOLE_NUMBER, parameterValues.get(0).type); Assert.assertEquals(1L, parameterValues.get(1).value); Assert.assertEquals(ParameterType.WHOLE_NUMBER, parameterValues.get(1).type); Assert.assertEquals("String", parameterValues.get(2).value); Assert.assertEquals(ParameterType.STRING, parameterValues.get(2).type); Assert.assertEquals(2L, parameterValues.get(3).value); Assert.assertEquals(ParameterType.WHOLE_NUMBER, parameterValues.get(3).type); Assert.assertEquals(-2L, parameterValues.get(4).value); Assert.assertEquals(ParameterType.WHOLE_NUMBER, parameterValues.get(4).type); Assert.assertEquals(2, ((byte[]) parameterValues.get(5).value).length); Assert.assertEquals(ParameterType.BYTE_ARRAY, parameterValues.get(5).type); Assert.assertEquals((byte) 0x00, ((byte[]) parameterValues.get(5).value)[0]); Assert.assertEquals((byte) 0x01, ((byte[]) parameterValues.get(5).value)[1]); Assert.assertEquals(7.777D, ((Double) parameterValues.get(6).value), 0.0001F); Assert.assertEquals(ParameterType.FLOATING_POINT_NUMBER, parameterValues.get(6).type); Assert.assertEquals(7D, parameterValues.get(7).value); Assert.assertEquals(ParameterType.FLOATING_POINT_NUMBER, parameterValues.get(7).type); } @Test public void should_create_query_with_in_clause() { // Setup final Query query = new Query("SELECT * FROM rows WHERE value = ? AND id IN(?)"); final int itemCount = 3; final List items = new ArrayList(itemCount); for (int i = 0; i < itemCount; ++i) { items.add("" + i); } // Action query.setParameter("value"); query.setInClauseParameters(items, ValueExtractor.STRING); final String queryString = query.getQueryString(); final List parameters = query.getParameters(); // Assert Assert.assertEquals("SELECT * FROM rows WHERE value = ? AND id IN (?, ?, ?)", queryString); Assert.assertEquals((itemCount + 1), parameters.size()); Assert.assertEquals("value", parameters.get(0).value); Assert.assertEquals("0", parameters.get(1).value); Assert.assertEquals("1", parameters.get(2).value); Assert.assertEquals("2", parameters.get(3).value); } @Test public void should_create_query_with_in_clause_using_null() { // Setup final Query query = new Query("SELECT * FROM rows WHERE value = ? AND id IN(?)"); // Action query.setParameter("value"); query.setInClauseParameters(null); final String queryString = query.getQueryString(); final List parameters = query.getParameters(); // Assert Assert.assertEquals("SELECT * FROM rows WHERE value = ? AND id IN (?)", queryString); Assert.assertEquals(2, parameters.size()); Assert.assertEquals("value", parameters.get(0).value); Assert.assertEquals(TypedParameter.NULL, parameters.get(1)); } @Test public void should_create_query_with_multiple_in_clauses() { // Setup final Query query = new Query("SELECT * FROM rows WHERE value = ? AND ( id IN(?) OR id IN (?) )"); final int firstItemCount = 3; final List firstItems = new ArrayList(firstItemCount); for (int i = 0; i < firstItemCount; ++i) { firstItems.add("" + i); } final int secondItemCount = 4; final List secondItems = new ArrayList(secondItemCount); for (int i = 0; i < secondItemCount; ++i) { secondItems.add("" + i); } // Action query.setParameter("value"); query.setInClauseParameters(firstItems, ValueExtractor.STRING); query.setInClauseParameters(secondItems, ValueExtractor.STRING); final String queryString = query.getQueryString(); final List parameters = query.getParameters(); // Assert Assert.assertEquals("SELECT * FROM rows WHERE value = ? AND ( id IN (?, ?, ?) OR id IN (?, ?, ?, ?) )", queryString); Assert.assertEquals((firstItemCount + secondItemCount + 1), parameters.size()); Assert.assertEquals("value", parameters.get(0).value); Assert.assertEquals("0", parameters.get(1).value); Assert.assertEquals("1", parameters.get(2).value); Assert.assertEquals("2", parameters.get(3).value); Assert.assertEquals("0", parameters.get(4).value); Assert.assertEquals("1", parameters.get(5).value); Assert.assertEquals("2", parameters.get(6).value); Assert.assertEquals("3", parameters.get(7).value); } @Test public void should_create_query_of_multiple_tuple_pairs() { // Setup final Query query = new Query("SELECT id FROM table WHERE (value0, value1) IN (?)"); final ValueExtractor> stringTupleExtractor = new ValueExtractor>() { @Override public InClauseParameter extractValues(final Tuple tuple) { final TypedParameter typedParameter0 = new TypedParameter(tuple.first); final TypedParameter typedParameter1 = new TypedParameter(tuple.second); return new InClauseParameter(typedParameter0, typedParameter1); } }; final MutableList> values = new MutableArrayList>(); for (int i = 0; i < 3; ++i) { values.add(new Tuple("Value0-" + i, "Value1-" + i)); } // Action query.setInClauseParameters(values, stringTupleExtractor); final String queryString = query.getQueryString(); final List parameters = query.getParameters(); // Assert Assert.assertEquals("SELECT id FROM table WHERE (value0, value1) IN ((?,?), (?,?), (?,?))", queryString); Assert.assertEquals(6, parameters.size()); } @Test public void should_create_query_with_tuples_and_regular_parameter() { // Setup final Query query = new Query("SELECT id FROM table WHERE (value0, value1) IN (?) AND `key` = ?"); final Long keyValue = 1L; final ValueExtractor> stringTupleExtractor = new ValueExtractor>() { @Override public InClauseParameter extractValues(final Tuple tuple) { final TypedParameter typedParameter0 = new TypedParameter(tuple.first); final TypedParameter typedParameter1 = new TypedParameter(tuple.second); return new InClauseParameter(typedParameter0, typedParameter1); } }; final MutableList> values = new MutableArrayList>(); for (int i = 0; i < 3; ++i) { values.add(new Tuple("Value0-" + i, "Value1-" + i)); } // Action query.setInClauseParameters(values, stringTupleExtractor); query.setParameter(keyValue); final String queryString = query.getQueryString(); final List parameters = query.getParameters(); // Assert Assert.assertEquals("SELECT id FROM table WHERE (value0, value1) IN ((?,?), (?,?), (?,?)) AND `key` = ?", queryString); Assert.assertEquals(7, parameters.size()); Assert.assertEquals("Value0-0", parameters.get(0).value); Assert.assertEquals("Value1-0", parameters.get(1).value); Assert.assertEquals("Value0-1", parameters.get(2).value); Assert.assertEquals("Value1-1", parameters.get(3).value); Assert.assertEquals("Value0-2", parameters.get(4).value); Assert.assertEquals("Value1-2", parameters.get(5).value); Assert.assertEquals(keyValue, parameters.get(6).value); } @Test public void should_create_query_with_expanded_in_clause() { // Setup final Query query = new Query("SELECT id FROM table WHERE key IN (?)"); final MutableList values = new MutableArrayList(); for (int i = 0; i < 3; ++i) { values.add("Value-" + i); } // Action query.setExpandedInClauseParameters(values, ValueExtractor.STRING); final String queryString = query.getQueryString(); final List parameters = query.getParameters(); // Assert Assert.assertEquals("SELECT id FROM table WHERE ((key = ?) OR (key = ?) OR (key = ?))", queryString); Assert.assertEquals(3, parameters.size()); Assert.assertEquals("Value-0", parameters.get(0).value); Assert.assertEquals("Value-1", parameters.get(1).value); Assert.assertEquals("Value-2", parameters.get(2).value); } @Test public void should_create_query_with_expanded_in_clause_with_tuple() { // Setup final Query query = new Query("SELECT id FROM table WHERE (key0, key1) IN (?)"); final ValueExtractor> stringTupleExtractor = new ValueExtractor>() { @Override public InClauseParameter extractValues(final Tuple tuple) { final TypedParameter typedParameter0 = new TypedParameter(tuple.first); final TypedParameter typedParameter1 = new TypedParameter(tuple.second); return new InClauseParameter(typedParameter0, typedParameter1); } }; final MutableList> values = new MutableArrayList>(); for (int i = 0; i < 3; ++i) { values.add(new Tuple("Value0-" + i, "Value1-" + i)); } // Action query.setExpandedInClauseParameters(values, stringTupleExtractor); final String queryString = query.getQueryString(); final List parameters = query.getParameters(); // Assert Assert.assertEquals("SELECT id FROM table WHERE ((key0 = ? AND key1 = ?) OR (key0 = ? AND key1 = ?) OR (key0 = ? AND key1 = ?))", queryString); Assert.assertEquals(6, parameters.size()); Assert.assertEquals("Value0-0", parameters.get(0).value); Assert.assertEquals("Value1-0", parameters.get(1).value); Assert.assertEquals("Value0-1", parameters.get(2).value); Assert.assertEquals("Value1-1", parameters.get(3).value); Assert.assertEquals("Value0-2", parameters.get(4).value); Assert.assertEquals("Value1-2", parameters.get(5).value); } @Test public void should_create_query_with_expanded_in_clause_with_escaped_tuple() { // Setup final Query query = new Query("SELECT id FROM table WHERE (`key0`, `key1`) IN (?)"); final ValueExtractor> stringTupleExtractor = new ValueExtractor>() { @Override public InClauseParameter extractValues(final Tuple tuple) { final TypedParameter typedParameter0 = new TypedParameter(tuple.first); final TypedParameter typedParameter1 = new TypedParameter(tuple.second); return new InClauseParameter(typedParameter0, typedParameter1); } }; final MutableList> values = new MutableArrayList>(); for (int i = 0; i < 3; ++i) { values.add(new Tuple("Value0-" + i, "Value1-" + i)); } // Action query.setExpandedInClauseParameters(values, stringTupleExtractor); final String queryString = query.getQueryString(); final List parameters = query.getParameters(); // Assert Assert.assertEquals("SELECT id FROM table WHERE ((`key0` = ? AND `key1` = ?) OR (`key0` = ? AND `key1` = ?) OR (`key0` = ? AND `key1` = ?))", queryString); Assert.assertEquals(6, parameters.size()); Assert.assertEquals("Value0-0", parameters.get(0).value); Assert.assertEquals("Value1-0", parameters.get(1).value); Assert.assertEquals("Value0-1", parameters.get(2).value); Assert.assertEquals("Value1-1", parameters.get(3).value); Assert.assertEquals("Value0-2", parameters.get(4).value); Assert.assertEquals("Value1-2", parameters.get(5).value); } @Test public void should_create_query_with_expanded_in_clause_with_tuple_and_extra_where() { // Setup final Query query = new Query("SELECT id FROM table WHERE (key0, key1) IN (?) AND filter = ?"); final ValueExtractor> stringTupleExtractor = new ValueExtractor>() { @Override public InClauseParameter extractValues(final Tuple tuple) { final TypedParameter typedParameter0 = new TypedParameter(tuple.first); final TypedParameter typedParameter1 = new TypedParameter(tuple.second); return new InClauseParameter(typedParameter0, typedParameter1); } }; final MutableList> values = new MutableArrayList>(); for (int i = 0; i < 3; ++i) { values.add(new Tuple("Value0-" + i, "Value1-" + i)); } // Action query.setExpandedInClauseParameters(values, stringTupleExtractor); query.setParameter(0); final String queryString = query.getQueryString(); final List parameters = query.getParameters(); // Assert Assert.assertEquals("SELECT id FROM table WHERE ((key0 = ? AND key1 = ?) OR (key0 = ? AND key1 = ?) OR (key0 = ? AND key1 = ?)) AND filter = ?", queryString); Assert.assertEquals(7, parameters.size()); Assert.assertEquals("Value0-0", parameters.get(0).value); Assert.assertEquals("Value1-0", parameters.get(1).value); Assert.assertEquals("Value0-1", parameters.get(2).value); Assert.assertEquals("Value1-1", parameters.get(3).value); Assert.assertEquals("Value0-2", parameters.get(4).value); Assert.assertEquals("Value1-2", parameters.get(5).value); Assert.assertEquals(0L, parameters.get(6).value); } } java-db-3.4.0/src/test/java/com/softwareverde/database/jdbc/000077500000000000000000000000001504445564400236305ustar00rootroot00000000000000java-db-3.4.0/src/test/java/com/softwareverde/database/jdbc/transaction/000077500000000000000000000000001504445564400261555ustar00rootroot00000000000000JdbcDatabaseTransactionTests.java000066400000000000000000000166721504445564400344750ustar00rootroot00000000000000java-db-3.4.0/src/test/java/com/softwareverde/database/jdbc/transactionpackage com.softwareverde.database.jdbc.transaction; import com.softwareverde.database.Database; import com.softwareverde.database.DatabaseConnection; import com.softwareverde.database.DatabaseException; import com.softwareverde.database.memory.mysql.MysqlMemoryDatabase; import com.softwareverde.database.query.Query; import com.softwareverde.database.row.Row; import com.softwareverde.database.transaction.DatabaseTransaction; import com.softwareverde.util.Container; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import java.sql.Connection; import java.sql.SQLException; import java.util.LinkedList; import java.util.List; class SingleConnectionDatabase extends MysqlMemoryDatabase { protected final Database _database; protected final DatabaseConnection _keepAliveDatabaseConnection; // Used to prevent the _database from being closed. protected final DatabaseConnection _databaseConnection; protected final List> _allConnections = new LinkedList>(); public SingleConnectionDatabase() throws DatabaseException { _database = new MysqlMemoryDatabase(); _keepAliveDatabaseConnection = _database.newConnection(); _databaseConnection = _database.newConnection(); _allConnections.add(_keepAliveDatabaseConnection); _allConnections.add(_databaseConnection); } @Override public DatabaseConnection newConnection() throws DatabaseException { return _databaseConnection; } public Connection getRawDatabaseConnection() { return _databaseConnection.getRawConnection(); } public DatabaseConnection actuallyGetNewConnection() throws DatabaseException { final DatabaseConnection newConnection = _database.newConnection(); _allConnections.add(newConnection); return newConnection; } public void initTables() throws DatabaseException { _databaseConnection.executeDdl("CREATE TABLE test_table (id INT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT, test_column VARCHAR(255) NOT NULL)"); } public void destroy() throws SQLException { for (final DatabaseConnection databaseConnection : _allConnections) { final Connection rawConnection = databaseConnection.getRawConnection(); if (! rawConnection.isClosed()) { rawConnection.close(); } } } } public class JdbcDatabaseTransactionTests { protected SingleConnectionDatabase _database; @Before public void setUp() throws Exception { _database = new SingleConnectionDatabase(); _database.initTables(); } @After public void tearDown() throws Exception { _database.destroy(); } @Test public void should_execute_sql_within_transaction() throws Exception { // Setup final DatabaseTransaction databaseTransaction = new JdbcDatabaseTransaction(_database); // Action databaseTransaction.execute(new DatabaseRunnable() { @Override public void run(final DatabaseConnection databaseConnection) throws DatabaseException { databaseConnection.executeSql(new Query("INSERT INTO test_table (test_column) VALUES (?)").setParameter("value")); } }); // Assert final Row row = _database.actuallyGetNewConnection().query("SELECT * FROM test_table", null).get(0); Assert.assertEquals("value", row.getString("test_column")); } @Test public void should_have_closed_database_connection_on_successful_transaction() throws Exception { // Setup final DatabaseTransaction databaseTransaction = new JdbcDatabaseTransaction(_database); // Action databaseTransaction.execute(new DatabaseRunnable() { @Override public void run(final DatabaseConnection databaseConnection) throws DatabaseException { databaseConnection.executeSql(new Query("INSERT INTO test_table (test_column) VALUES (?)").setParameter("value")); } }); // Assert Assert.assertTrue(_database.getRawDatabaseConnection().isClosed()); } @Test public void should_have_closed_database_connection_on_unsuccessful_transaction() throws Exception { // Setup final DatabaseTransaction databaseTransaction = new JdbcDatabaseTransaction(_database); // Action try { databaseTransaction.execute(new DatabaseRunnable() { @Override public void run(final DatabaseConnection databaseConnection) throws DatabaseException { databaseConnection.executeSql(new Query("INVALID QUERY: SYNTAX ERROR").setParameter("value")); } }); } catch (final DatabaseException databaseException) { } // Assert Assert.assertTrue(_database.getRawDatabaseConnection().isClosed()); } @Test public void should_have_closed_database_connection_on_empty_transaction() throws Exception { // Setup final DatabaseTransaction databaseTransaction = new JdbcDatabaseTransaction(_database); // Action databaseTransaction.execute(new DatabaseRunnable() { @Override public void run(final DatabaseConnection databaseConnection) throws DatabaseException { // Nothing. } }); // Assert Assert.assertTrue(_database.getRawDatabaseConnection().isClosed()); } @Test public void should_rollback_statements_if_one_fails() throws Exception { // Setup final DatabaseTransaction databaseTransaction = new JdbcDatabaseTransaction(_database); try (final DatabaseConnection databaseConnection = _database.actuallyGetNewConnection()) { databaseConnection.executeSql(new Query("INSERT INTO test_table (test_column) VALUES (?)").setParameter("original value")); } final Container midTransactionValue = new Container(); // Action try { databaseTransaction.execute(new DatabaseRunnable() { @Override public void run(final DatabaseConnection databaseConnection) throws DatabaseException { databaseConnection.executeSql(new Query("UPDATE test_table SET test_column = ?").setParameter("new value")); final Row row = databaseConnection.query("SELECT * FROM test_table", null).get(0); midTransactionValue.value = row.getString("test_column"); databaseConnection.executeSql(new Query("INVALID QUERY: SYNTAX ERROR")); } }); } catch (final DatabaseException databaseException) { } // Assert Assert.assertEquals("new value", midTransactionValue.value); // Assert the initial update was successful before the rollback... try (final DatabaseConnection databaseConnection = _database.actuallyGetNewConnection()) { final Row row = databaseConnection.query("SELECT * FROM test_table", null).get(0); Assert.assertEquals("original value", row.getString("test_column")); } } }java-db-3.4.0/src/test/java/com/softwareverde/database/memory/000077500000000000000000000000001504445564400242365ustar00rootroot00000000000000java-db-3.4.0/src/test/java/com/softwareverde/database/memory/mysql/000077500000000000000000000000001504445564400254035ustar00rootroot00000000000000java-db-3.4.0/src/test/java/com/softwareverde/database/memory/mysql/MysqlMemoryDatabase.java000066400000000000000000000025071504445564400321750ustar00rootroot00000000000000package com.softwareverde.database.memory.mysql; import com.softwareverde.database.Database; import com.softwareverde.database.DatabaseConnection; import com.softwareverde.database.DatabaseException; import java.sql.Connection; import java.sql.SQLException; public class MysqlMemoryDatabase implements Database { protected static Integer _nextSequenceNumber = 0; protected final Integer _sequenceNumber; protected Connection _connect() throws SQLException, ClassNotFoundException { Class.forName("org.h2.Driver"); return org.h2.Driver.load().connect("jdbc:h2:mem:db"+ _sequenceNumber +";MODE=MYSQL", null); } public MysqlMemoryDatabase() { _sequenceNumber = _nextSequenceNumber; _nextSequenceNumber += 1; } @Override public DatabaseConnection newConnection() throws DatabaseException { try { final Connection connection = _connect(); return new MysqlMemoryDatabaseConnection(connection); } catch (SQLException | ClassNotFoundException exception) { throw new DatabaseException("Unable to connect to _database.", exception); } } /** * Require dependencies be packaged at compile-time. */ private static final Class[] UNUSED = { org.h2.Driver.class }; }MysqlMemoryDatabaseConnection.java000066400000000000000000000127571504445564400341460ustar00rootroot00000000000000java-db-3.4.0/src/test/java/com/softwareverde/database/memory/mysqlpackage com.softwareverde.database.memory.mysql; import com.softwareverde.database.DatabaseConnection; import com.softwareverde.database.DatabaseException; import com.softwareverde.database.query.Query; import com.softwareverde.database.query.parameter.TypedParameter; import com.softwareverde.database.row.Row; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.ArrayList; import java.util.List; public class MysqlMemoryDatabaseConnection implements DatabaseConnection { private final Connection _connection; private TypedParameter[] _getTypedParametersAsArray(final List typedParameters) { final TypedParameter[] typedParameterArray = new TypedParameter[typedParameters.size()]; for (int i = 0; i < typedParameterArray.length; ++i) { typedParameterArray[i] = typedParameters.get(i); } return typedParameterArray; } private TypedParameter[] _stringArrayToTypedParameters(final String[] parameters) { if (parameters == null) { return null; } final TypedParameter[] typedParameters = new TypedParameter[parameters.length]; for (int i = 0; i < parameters.length; ++i) { typedParameters[i] = new TypedParameter(parameters[i]); } return typedParameters; } private List _query(final String query, final TypedParameter[] typedParameters) throws DatabaseException { try { final List results = new ArrayList(); try (final PreparedStatement preparedStatement = _prepareStatement(query, typedParameters); final ResultSet resultSet = preparedStatement.executeQuery() ) { if (resultSet.first()) { do { results.add(MysqlMemoryRow.fromResultSet(resultSet)); } while (resultSet.next()); } } return results; } catch (final SQLException exception) { throw new DatabaseException("Error executing query.", exception); } } private PreparedStatement _prepareStatement(final String query, final TypedParameter[] parameters) throws SQLException { final PreparedStatement preparedStatement = _connection.prepareStatement(query); if (parameters != null) { for (int i = 0; i < parameters.length; ++i) { final TypedParameter typedParameter = parameters[i]; switch (typedParameter.type) { case STRING: { preparedStatement.setString(i + 1, (String) parameters[i].value); } break; case BYTE_ARRAY: { preparedStatement.setBytes(i + 1, (byte[]) parameters[i].value); } break; case WHOLE_NUMBER: { preparedStatement.setLong(i + 1, (Long) parameters[i].value); } break; case FLOATING_POINT_NUMBER: { preparedStatement.setDouble(i + 1, (Double) parameters[i].value); } break; } } } return preparedStatement; } private void _executeSql(final String query, final TypedParameter[] parameters) throws DatabaseException { try (final PreparedStatement preparedStatement = _prepareStatement(query, parameters)) { preparedStatement.execute(); } catch (final SQLException exception) { throw new DatabaseException(exception); } } public MysqlMemoryDatabaseConnection(final Connection connection) { _connection = connection; } @Override public void executeDdl(final String query) throws DatabaseException { try { final Statement statement = _connection.createStatement(); statement.execute(query); statement.close(); } catch (SQLException sqlException) { throw new DatabaseException(sqlException); } } @Override public void executeDdl(final Query query) throws DatabaseException { this.executeDdl(query.getQueryString()); } @Override public Long executeSql(final String query, final String[] parameters) throws DatabaseException { final TypedParameter[] typedParameters = _stringArrayToTypedParameters(parameters); _executeSql(query, typedParameters); return 0L; } @Override public Long executeSql(final Query query) throws DatabaseException { _executeSql(query.getQueryString(), _getTypedParametersAsArray(query.getParameters())); return 0L; } @Override public List query(final String query, final String[] parameters) throws DatabaseException { final TypedParameter[] typedParameters = _stringArrayToTypedParameters(parameters); return _query(query, typedParameters); } @Override public List query(final Query query) throws DatabaseException { return _query(query.getQueryString(), _getTypedParametersAsArray(query.getParameters())); } @Override public void close() throws DatabaseException { try { _connection.close(); } catch (final SQLException sqlException) { throw new DatabaseException(sqlException); } } @Override public Connection getRawConnection() { return _connection; } } java-db-3.4.0/src/test/java/com/softwareverde/database/memory/mysql/MysqlMemoryRow.java000066400000000000000000000056221504445564400312410ustar00rootroot00000000000000package com.softwareverde.database.memory.mysql; import com.softwareverde.database.row.Row; import com.softwareverde.util.StringUtil; import com.softwareverde.util.Util; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class MysqlMemoryRow implements Row { public static MysqlMemoryRow fromResultSet(final ResultSet resultSet) { final MysqlMemoryRow mysqlRow = new MysqlMemoryRow(); try { final ResultSetMetaData metaData = resultSet.getMetaData(); for (int i = 0; i < metaData.getColumnCount(); ++i) { final String columnName = metaData.getColumnLabel(i + 1).toLowerCase(); // metaData.getColumnName(i+1); final String columnValue = resultSet.getString(i + 1); mysqlRow._columnNames.add(columnName); mysqlRow._columnValues.put(columnName, columnValue); } } catch (final SQLException exception) { } return mysqlRow; } private List _columnNames = new ArrayList(); private Map _columnValues = new HashMap(); private MysqlMemoryRow() { } private String _getString(final String columnName) { return _columnValues.get(columnName.toLowerCase()); } @Override public List getColumnNames() { return new ArrayList(_columnNames); } @Override public String getString(final String columnName) { return _getString(columnName); } @Override public Integer getInteger(final String columnName) { return Util.parseInt(_getString(columnName)); } @Override public Long getLong(final String columnName) { return Util.parseLong(_getString(columnName)); } @Override public Float getFloat(final String columnName) { return Util.parseFloat(_getString(columnName)); } @Override public Double getDouble(final String columnName) { return Util.parseDouble(_getString(columnName)); } @Override public Boolean getBoolean(final String columnName) { return Util.parseBool(_getString(columnName)); } @Override public byte[] getBytes(final String columnName) { return StringUtil.stringToBytes(_getString(columnName)); } @Deprecated @Override public LocalDate getDate(String columnName) { throw new UnsupportedOperationException(); } @Deprecated @Override public LocalTime getTime(String columnName) { throw new UnsupportedOperationException(); } @Deprecated @Override public LocalDateTime getDateTime(String columnName) { throw new UnsupportedOperationException(); } } java-db-3.4.0/src/test/java/com/softwareverde/database/query/000077500000000000000000000000001504445564400240735ustar00rootroot00000000000000java-db-3.4.0/src/test/java/com/softwareverde/database/query/BatchedInsertQueryTests.java000066400000000000000000000107161504445564400315330ustar00rootroot00000000000000package com.softwareverde.database.query; import org.junit.Assert; import org.junit.Test; public class BatchedInsertQueryTests { @Test public void should_create_batched_query_with_batch_size_1() { // Setup final BatchedInsertQuery batchedInsertQuery = new BatchedInsertQuery("INSERT INTO table (column0, column1, column2) VALUES (?, ?, ?)"); batchedInsertQuery.setParameter("valueA0"); batchedInsertQuery.setParameter("valueB1"); batchedInsertQuery.setParameter("valueC2"); // Action final String query = batchedInsertQuery.getQueryString(); // Assert Assert.assertEquals("INSERT INTO table (column0, column1, column2) VALUES (?, ?, ?)", query); } @Test public void should_create_batched_query_with_batch_size_2() { // Setup final int batchSize = 2; final BatchedInsertQuery batchedInsertQuery = new BatchedInsertQuery("INSERT INTO table (column0, column1, column2) VALUES (?, ?, ?)"); for (int i = 0; i < batchSize; ++i) { batchedInsertQuery.setParameter("valueA" + i); batchedInsertQuery.setParameter("valueB" + i); batchedInsertQuery.setParameter("valueC" + i); } // Action final String query = batchedInsertQuery.getQueryString(); // Assert Assert.assertEquals("INSERT INTO table (column0, column1, column2) VALUES (?, ?, ?), (?, ?, ?)", query); } @Test public void should_create_batched_query_with_batch_size_7() { // Setup final int batchSize = 7; final BatchedInsertQuery batchedInsertQuery = new BatchedInsertQuery("INSERT INTO table (column0, column1, column2) VALUES (?, ?, ?)"); for (int i = 0; i < batchSize; ++i) { batchedInsertQuery.setParameter("valueA" + i); batchedInsertQuery.setParameter("valueB" + i); batchedInsertQuery.setParameter("valueC" + i); } // Action final String query = batchedInsertQuery.getQueryString(); // Assert Assert.assertEquals("INSERT INTO table (column0, column1, column2) VALUES (?, ?, ?), (?, ?, ?), (?, ?, ?), (?, ?, ?), (?, ?, ?), (?, ?, ?), (?, ?, ?)", query); } @Test public void should_create_batched_query_supporting_on_duplicate_key_update() { // Setup final int batchSize = 3; final BatchedInsertQuery batchedInsertQuery = new BatchedInsertQuery("INSERT INTO table (column0, column1) VALUES (?, ?) ON DUPLICATE KEY UPDATE column1 = NULL"); for (int i = 0; i < batchSize; ++i) { batchedInsertQuery.setParameter("valueA" + i); batchedInsertQuery.setParameter("valueB" + i); } // Action final String query = batchedInsertQuery.getQueryString(); // Assert Assert.assertEquals("INSERT INTO table (column0, column1) VALUES (?, ?), (?, ?), (?, ?) ON DUPLICATE KEY UPDATE column1 = NULL", query); } @Test public void should_create_batched_query_with_static_parameter() { // Setup final int batchSize = 3; final BatchedInsertQuery batchedInsertQuery = new BatchedInsertQuery("INSERT INTO table (column0, column1, column2) VALUES (?, ?, 1)"); for (int i = 0; i < batchSize; ++i) { batchedInsertQuery.setParameter("valueA" + i); batchedInsertQuery.setParameter("valueB" + i); } // Action final String query = batchedInsertQuery.getQueryString(); // Assert Assert.assertEquals("INSERT INTO table (column0, column1, column2) VALUES (?, ?, 1), (?, ?, 1), (?, ?, 1)", query); } @Test public void should_create_batched_query_with_batch_size_7_with_static_parameter_and_duplicate_update_clause() { // Setup final int batchSize = 7; final BatchedInsertQuery batchedInsertQuery = new BatchedInsertQuery("INSERT INTO table (column0, column1, column2) VALUES (?, 1, ?) ON DUPLICATE KEY UPDATE column1 = VALUE (column1)"); for (int i = 0; i < batchSize; ++i) { batchedInsertQuery.setParameter("valueA" + i); batchedInsertQuery.setParameter("valueC" + i); } // Action final String query = batchedInsertQuery.getQueryString(); // Assert Assert.assertEquals("INSERT INTO table (column0, column1, column2) VALUES (?, 1, ?), (?, 1, ?), (?, 1, ?), (?, 1, ?), (?, 1, ?), (?, 1, ?), (?, 1, ?) ON DUPLICATE KEY UPDATE column1 = VALUE (column1)", query); } }