pax_global_header00006660000000000000000000000064136501160140014507gustar00rootroot0000000000000052 comment=5cf5722588b6bddf5467a4b1b0d8027af04bc419 java-db-3.2.5/000077500000000000000000000000001365011601400130225ustar00rootroot00000000000000java-db-3.2.5/.gitignore000066400000000000000000000001061365011601400150070ustar00rootroot00000000000000.gradle /local.properties .DS_Store /build bin out .idea /*.iml tmp java-db-3.2.5/LICENSE000066400000000000000000000020671365011601400140340ustar00rootroot00000000000000The 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.2.5/README.md000066400000000000000000000011111365011601400142730ustar00rootroot00000000000000# 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.2.5/build.gradle000066400000000000000000000041331365011601400153020ustar00rootroot00000000000000group 'com.softwareverde' version '3.2.5' apply plugin: 'java' apply plugin: 'java-library' sourceCompatibility = 1.8 task makeJar(type: Jar) { manifest { attributes 'Implementation-Title': 'Java Database Wrapper', 'Implementation-Version': version } from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } } with jar } repositories { mavenCentral() maven { url "https://jitpack.io" } } dependencies { implementation group: 'com.github.softwareverde', name: 'java-util', version: 'v2.1.0' 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.2.5/gradle/000077500000000000000000000000001365011601400142605ustar00rootroot00000000000000java-db-3.2.5/gradle/wrapper/000077500000000000000000000000001365011601400157405ustar00rootroot00000000000000java-db-3.2.5/gradle/wrapper/gradle-wrapper.jar000066400000000000000000001536261365011601400213670ustar00rootroot00000000000000PK 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 Af -org/gradle/wrapper/BootstrapMainStarter.classV[WWd`c@7.VJ -lD!NfK{O]} >i@,֙3}g?p ?(₂LxKE2(UL+!`bցBvdde(¼g(N\n wKb%xW{x_ށe+8 9gX;J$I@Үaji;Ih.UN1]t\Nm^ftʺrg!\[c6uκa}a/&ѝ"EFAC^KfcNPyrw+8 㾅\H(kOİ!' wWC_WLwi6ku{nhwW3zSB.>kVEFbX^'Zk%CZ1UrN 9QЮJ)a8mxwU(ɰT(@,GȨpQUq)eꙔ_Yǒ콋\Tb_[CP]GhoyX}s|K|EhFFSC {3\r(Ij4v5*r]L |jWi X `JŷN=] CAG v-6Jص榈DzL7{٢!͞r+r7RE O:S?{^#I?s &- 0e0NSgg*B' Ga 񙑧3RtGN jcD_I<\?jנVK 4=JO thXhMo3NiL9&Z7 MۖP6( K82$6V]S䡍G L쉱SM3dzĈ`baEIB.ò_hRl?R3cdBr58H2CnH61Oƅ A/N4J q f>=<\5,r}+\!Ƽq>D.r" 'OtLҹ#i1՗~Jņ:{= J[zeRPK A5<!org/gradle/wrapper/Download.classY |\YNXi;ˉKd˒v ~' ~_5xP5/ Oςx_T_R͟ ޏT_uo[|E5WEioG6z/~j;#g&KQ[5E+}G5S7Tjo)nBEL0_YSJ,bI7IU]4:kbRcH"ՙRo2O rYaJ*CVƔ)k Yg d)ME&ɔ[M͔ͦl1vSҠ6fH!M+pθJ9)AM^9&+9{СhWoٺhzn,1OPәL<; cJHh\Qn"JkAuÇENH ēNm=w.uI18!MŒ ApT;ڧ>=ַ;%b~AG,6}1eېיuݱӓq{$(%G8Gy1R*S䒚}7Y3֏&㱉,L T '5XN kI%⎖`ccJ5K)+dIyDNVmZ&ˣδ̮ ;Nn|\VN9 ' Hz|\eLřHO;JNoyNb›d,9֙L+!c"Wڮ)H8JU*PL{Usztڣ{1._YJObH!ml7d!;owݘ`_o[O:$fMwةxn+FG c\9+1$)gCQ]7ɬrR?xE ǛLҗk\g# 2f> [$-6h `V,#o?UiA{JT)aZģ9!pc,*|a5! c^F l-vb+V؆ B+cA]6j3+tӺG*Q9zyU7P;̢:,K֥VoZ۵l+.'WxEdZ5gPAƦYۘ;쒂MuԲCڋ?̾( ܄ٯvug=0SY 2Xkl f._n}p`mؗv|l7h`՞=5a`1udy +?M[3mC[fq˫jVV]ԬU+u=ϡ mˠ&:{I @H}V$h +2h~ Z0 Zn/׽Nuu|U!}/ }万Ќ؉t=.FG13= K/ 8%1WqO 8/,uY< ~*baDRZwGԝx3q J¹'.U68{A|?D5uWCk^OVJ|JK))U!xCήh_'ɍk 735~x@d.%IM Q7iM ] |& ~Lܤ=e-*S*Ms1ܘNasvNߞYuPBlҥ">H9M|/ڛ(+}OI|79t}h$wA'sؘtCtd s=Ľy_ُ`: w46]cvfVL&P)q pq`N4gp$tXOsw8 kd~N W628IW+ҕanah8tJ[^&$OK7FzdaҬ˓,~$KQc,$寳r˷ܷ1jKeFp>cԯE cOa_?+MI:7Y TJGo\H$h*d0;HsGhԉi=7p n]._xoLK6_2^-d*}R|eaLQ~e^au}[O2M4k}9rz~BTbvڞSچd O 4Zo3}a?0$:ga):\hfcDcl U<ԯ!tGX}[Y}ʶYrȟґOkBh„ !*z=?ٍ_a/@W_ńFU`\_MEN"mPK 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:;"+) QgѰ?ѹZ>f\z\P$ȦaXaif\ǚl=CpCjaa!@!#v@bÎ =21f?}dE} +i ;~*aDigI}iJۄJX׺r Mtep|7HX HLVq$9JWsQZl6oY)tdDL{:&QΪb﹘MdUki1;e|N!+ym->J0CK g@㱈 !Ga81wa}cWy|ͯ8&|~&kö)AM /K2+*yH(>떄mGMo6-> .'*~8s*eHŏ +\6a: TypOs=8HFq=ʬ1s .؈'_L8Ǡ_F՜4̚OjkNF&kjk7aSzR%T,ĕURIaIeBA,fS?j ,Kl?1Vt/_RbAws@tOY; ^6ś͑DTYsgHd+hYƈ]lxf:neӭ籄}hY(lMuys Ĉ;Bj ȇ}R@n^GoyGFa0Tevnqq]醶YCni*iknԖs#.N3("QUL͹7effLνd}H5&3N]yE v~[镊jю4beh5i 5Pl{¹YR:J叶G`ڗ:;ؔ̃l`a7"\75s'/T*UFI7LsCqJS=~O*J|eڛ$g\)SXĝb['dKeLjeY˓nMbt$V5*~~ Ճ)H}}5)<5~o v >q=\KC(G=aVa#c:؂a+c&`7EV\`a1=c7Y$Jg(A܍c:58'b8t(S 1籍Q]nab8Nr$D͛~:!b-o-9`.IlӤ YS1 UOF-u`P _wF)}#VeFߥ:\e_@342[$6o%Ǥ5+ nYo4NSؖ$v$;v nHauh5%~,D߭;XT;RzZ]EU0cvIBjˤcTTV2FV*$!o8b8KCB0JeLv ᥰz_Y- ('I &_x(+(8V0fTm# 0-fWZLډ^AQ)t;d\yNl'PK A"org/gradle/wrapper/IDownload.classE 0  ^b* A{(l|JTf $_uX! n6mla{<}w"MxkC6GeͤlLa3X1V`Ô8rWٻr O6E!1)ʕʕTD rS4>#60>׌q|^6_PEptWe󀂯U|C7cķƷx<`F#ukdtk7-C12h2YkN=ӱG\d^jdJ+XƱK9δR9WZFꄫ ZQ O꛶l.N ,Υ)`& y nYRninK .FY/PQw {,o}yڴ'd2,kyy1,O)6[z`pz'YԚn̛WC VV;1Ħuwp0>m9zGA?jC|8nXֹoҔ]Tr: &Z==35}*xL]=AAWUŁcFFBX6ll+tw@ :St]RXذSt3FpWZ9Rgg,@ ޤU{v [U6ټ5`إaO[4Wד֢ie W# O4LixZ~jxF6?k?dz hx Di>Yz;Œsp^ ~55 ~w«3,ÓqOuY_W 7 lxE^3Atx;-z{h y77 owz, Y2H+B2=uq+'Ԝ욋#2{~^ loXEJȚӒ3#鉯|G?Mo#".@=<]@943+ؔ?*a ֬/m\r1ظrW 4>ph9\=%Wh[]%\CVx<ք֮u=.HHN>DV%S^%W GAw'`X"D/nC8Hi1ų8 ǐxuobg,[AfAvԻ?фx8"NYD"b \#(Wn Ԗ=]xBb c :&(Z2%R)?E*a㙆eU3l? /QR\PK AT,-t+ org/gradle/wrapper/Install.classY |T?'!  $H4 HXe%%μ! j-Vk[-ZתhUP kZܪM֪d #ws?˽My4#)(iFgɑf|uS!*Gn+k.$J3Gnj- knnf4~7MMyJ3mpy.*l9a.vy//4)M&6֣UA-cLnm\v6\)M3Ac<4:(W *-t fwL-O ;+su b_f@|C.b Y04 R{lmz'W KBpGFWy= VZ!+[蹩=jqtu-Qz.X_34lljq4~WUbFCmM)|V> U7*z4ҕ55kCtW1_4nD!(kƃuSBW{. _,Yզn 2|LJȲ4Qģ>0]q-A:ofK h kF<CdcQ 8z4p Nk|B_k~+ $n hn" iaN@8MeだEۙ #J┕alCSVX p* iah«m 5h8ۯu D%7XƗ٢:;fcFzo@]&=lDR1I52"A H$UiT@}^p<d%[(ۓ/o& _w!iJ FLeTf,As6\hѭڝ>k,+N8duΒf4s-[eNɭ2&Tu$4G-9qBOc:F 5Ohsϗg YswY ,>asMV7ۂW&TzQzW^zXTzPJ7UzRr P)ҷ2vU_5|*oPG|х>[TF "Kn\YYjE4Gʷ*Ʒ|%s٠*wQ^4UgrA5驘ʹtSoz=G71(? -j.L"F$ykkD-^8坝URU[T0m:*c" }5Tt+ݦCOnhj*37CO燛͌sBZMۦ{u=5PmoGh+y454ܞmFB]+E7r"# %^- A 1K,D#!5*D0ozAET͏凓+U Y)[i(VEؐ{č|*ܫbGuF. *?Jo?$lF ́p>O!;d"(El WPyZgY)H1=CFT~%KR/Bi,_iSReͯ!H<7(#YzQoK$Zᕨk꠮N^9p@ -l1G`puw%+ Su~Cߩ{?a*T~R6 Ό%J;*+ 5i!uIc`POCbŎW/?ToG|lvrBV6"+ L]26\<&C7._A;A-ˌr#X4/R ĸaXu ;Wdbd‘0 %Ը  f&thaDZK og>~cWB3}fIO^1t WO~ VbI,\"y/9^%"V Y(fIq(qZn5~_IXlH$=dCAawj9֚s1 0<x;4MGzMPi$># eݧ9C[{]O?\:hxuђQ[h;^T},*G#;|r^K'46HEooU&|}z&ϥ4ͨh^FW=nʩpcL=^Tqz%ť=MY@D*L>WZ\JW5AZT4~mX[D?l"休n¬i4~7'݌vkp ȥ9&4Q‘kϺ&z4i=~K'%-BNnI7MSz[r];hh8s]s/O'Ud{i6QFꦓ7x难awQ)_b3ղFϥj4i&(?BPGNh mŌ Bt>E }QTa շCItͧ;'SjXu 匤m?9{A).Ůs)~3:4BSB{|AT>B3ɃPc1AgCLh(=@3fK3r Paq?!h ɭöTE 0ׁbv_.*xho4`bͷ}PbVnrW5'=#jȦ#4]SK'D| :&jJ*̺R7QLI(mlrz"Yc/Dη{R)2| 6A`Ա(Ĕ߹xY\iz}*=XMII_CKē̷LߌooLqz"!xWB8)1xT4Z`-p oicN;I-8В,ڰxzSL;a\~@`\N}Jʄ-]/JY9j"Ф|P'J)~ _clNE KyM9K{zneMGɖͩ9a MV6Rm|CgPDz(B jp=My%gwڀx$dM.d]WD6H \!bKMxNn nM`f쁄h>u Kyh)Aʺ3vSrD PڃȴQ!nhp`0àpsivrY%t934d: z^+Lz+0e5Y_WL8N00)c96r+iyThB)Rz#4}}'-W /Do×ẍ́-IK+wu'9mSc$Xb0Q8BB FL]:^8Ȓ"x.,6= z%M',<!a۽&ކYf al< ŋp9О8cObª̠7-S);,?vs<3ɒ6el.nuM/Jfn`pd^2 (DCn/^v8Mz(C1*tgᖫm(N6Nq=BnB( KwR lqC5 1ކޡS!2z?>DF>F,>>ASkt6 mBa >;Cg)e_VtW˚S~Di)(>V+٤\FЭd|FY}#5P,[$3E#'+)nF5eWCq)ʭhDIYluB֟\hST{FŋK@ )Mc=&1S͢!#=B(v4t VbpWY4h൦g 10+D*w0n9p92!83i՚`//bq-|N,H,Ye^m$gJ*%d-cgGBͫ .۞͕%pqAVb4 23+6_nΛ p63)3>2(|VQJBGPK A:o4org/gradle/wrapper/Logger.classko`Unc@&s*]711$KH`wʓ_OFg ?xR5Krw.??hG b1TP4w+ͶU].;`XxfX!R9Ӳ!1,j<8>?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 Aon`8org/gradle/wrapper/PathAssembler$LocalDistribution.classR[KAfV㪽K>ERPC&ɐL\wd BJLB1V}3'}ḷ%xX3Kc^xBjW}B'EH%t4˻jt'hNd|E/uE` ϚԌ>T ihdmIXlTϚR $%'I%,!ת9UOi*A"[͔~[ؑݔ]Ouw%㭚P8H .@ \s> X)H;fOrBfVY5 UBe#Vxxv.|D#Pt '^sazO1HPL4bg8zձaXWdm WivDPK AJ[&org/gradle/wrapper/PathAssembler.classVicW=cKYǎb'c1, 4@5Qk[q[yyF e)})P(C]hPob;wf,ٮLzﾧ9wy??#r-c=#nȐaC%YU<A9ٱE*\@Mپ%æ|R0>t|VgU|NGp_ᶊT<#Ka|Y"WDoM a|;ໂb rE/)8:]Xfɱղc,Zڲ {"JFIscS+Ss+f3S+ s陋 z*[< XQm薳ˆ#fX:lX,†hxfBa3oDA2 K ,ڧM˘)o7_/)k3ଛd?]s)*u֋EN]֝1zAM@G=g8od1o\EwtmQp^+ i ]Ҭ'څݰ*pKW̢[.lyl/uJ' TsƤ3J>OdmJeM#tu\BX\3~|B%v#BiMcj1FKat4cW~pRsCB ]զ"@DhwIsx" 9B^3dſF䄆Q<8&񄆏cVCӼ{-k^Ѱ5,f>k~,:?Oj? ~W}E/6~f0ˋ|@ū~j~Nm\rP(b[輦X+Ε-0;Q(1Y1*W*#bt_;hw.v*835_Y~3]-dM[v$AU*|3Ku*"ߎ3׍5gּ_z@wk3ް*$/PVV;~Is >>ГZۘ_xv7@'O+D}vJC Yݡ`0 e}P$56gKEӍqU`<]rJ]`C,x\5aY'c{"LJz?gs0Qzc3ЇG(i>1b`705E7";h[9BZwU4[Z:iDZBbI|;@&1TEp&1"t>uY WѲr\iEpp]ݣtt]i~(cˉ`w;=qӕA#a׵Kk1V .2M@Ce|y4,ތ؏`eU8M^g2zz_F0lmNQ׳GidYK;[CIJR %><)6{2C } 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׃\&9I9UZ;;:"@x°v.UkʮۤXRbI3D -k|Z*tzDB!4q< bALC[j]yƖ~D=' * f] Lrs Z(ܚKL=VML̖lc:N>}PWщE(QɊ$Uio馥U1Q>1r˫b-gq:ڻf9cЩy{բ:9OR/iPFFzPH 4mi^ڃ'xA3 B&P&`Sh!^ Hp)LcNG{&ſƃ精.R$(A.%R,N`~vXlMl,݉: A&CA' 7"!Yr8GR (6^f"pfSQ;!neGl=Zs> wDO7Rx0D!o)<=PK 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 A <org/gradle/cli/CommandLineParser$BeforeFirstSubCommand.classVRF#ĸ5|ܒ`$[qpZ'&Bql9#M^зHg!)Ӥ:ӷ߾C;=+9`bL&3=o?=: sx c'葑"GN%Y\ r|$+ 8p㦌[D82X(pa跿3|ݪ+UZHk5~G#ay `V[:)aXoʺuW-W5ZXY-a5bɠ2MZNEOAmEγ0 ͢ZvmMݹ6m9~YIm0+N˔7Z!]?vuO"wtIUh8*\Xk۷G(2l>¬{'31+s ^cQΈL aː:{ 69 Jdz>dxFgnfQ.nOO_<܁'Z=O=6> 6L{(3jK6q/G H}4"Y|Gw! <@)|R JTB;|pI^!yJ= Nt3D5Q[B]F]qšۣcD[̦hC#I>GIuM; Dm@XFٜ8BsjO;9l/tq иBjQ|,1%MgyF  U^9ۄW4~-PK 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 A2 =org/gradle/cli/CommandLineParser$KnownOptionParserState.classXwdlFMHybژ6 6;n63qf6 ZmQjjikRUOn]~uϻNL!!1eLPB2a F ACaÆD01 BX'x*<3xO a7~ʄ? y E>%^b֗%"Uqtw,HHx0;gahkՓTm[#hOXj<ǒz{9<nhT֬w znC,2">XJlGu4 ogB?# :MU)eE:=m:);퓪h!ݮ= znNž/9i@ c[˘$ޯYITF̘P->2acg՜hn*l@~Vm4DjX3{sմT ya`:n)B6)ֹ49T;{ƦHRc/)L`:C/=y gz`9B›ޒYYzE祓 l6.)+m994m52qCX,ݖGe܉M2.e<dl2hM2 &\:Po7(qStG=)b6w?Ȳ6oBm(s(æ2bz\+6 d2v""2N"*wtyn۔U^ЕQ6FbS8-=㌌?਌?r$RIGz̈1,,$|pn׽‘q1"PɘĔ߱ t.0-σk]ThYLu [X[^GTǴhJjm!Ԝi-Xԫ7:{# QaRobf$!WW/͇B<4NIs,3QhJiS`;r5ln= ֕y<9R9B=rZ:OS+g_kң֟`Yؔ*\f,grzs:I4 Yؔx@нA=s(lNpEk}'})TM5ϠZ`K.b ssXʎ9(cW owiBHz:DA_LlJO _[f9&#xFz]M&8vtP ]}-3Vp5:3S?CݐkADx:nq +eO)Q9T&ė8&KB|+䓷) wQq=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 AdZl)&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>.axtv2Ώg9+#_;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 AWgradle-cli-classpath.properties+(JM.)**+MPK A AMETA-INF/PK Am>=@?)META-INF/MANIFEST.MFPK AAorg/PK A Aorg/gradle/PK AAorg/gradle/wrapper/PK Af -org/gradle/wrapper/BootstrapMainStarter.classPK AhQ}#korg/gradle/wrapper/Download$1.classPK AL4Norg/gradle/wrapper/Download$ProxyAuthenticator.classPK A5<! org/gradle/wrapper/Download.classPK AyL1org/gradle/wrapper/DownloadProgressListener.classPK A!9| 3org/gradle/wrapper/ExclusiveFileAccessManager.classPK A,y- org/gradle/wrapper/GradleUserHomeLookup.classPK A!l7 "*u#org/gradle/wrapper/GradleWrapperMain.classPK A",org/gradle/wrapper/IDownload.classPK Ap@c "-org/gradle/wrapper/Install$1.classPK AT,-t+ 5org/gradle/wrapper/Install.classPK A:o4Iorg/gradle/wrapper/Logger.classPK Aon`8Lorg/gradle/wrapper/PathAssembler$LocalDistribution.classPK AJ[&Norg/gradle/wrapper/PathAssembler.classPK A| 0Uorg/gradle/wrapper/SystemPropertiesHandler.classPK A=?-[org/gradle/wrapper/WrapperConfiguration.classPK AG ( ^org/gradle/wrapper/WrapperExecutor.classPK A_#dggradle-wrapper-classpath.propertiesPK AAgorg/gradle/cli/PK A?<S1gorg/gradle/cli/AbstractCommandLineConverter.classPK A׃X ;}jorg/gradle/cli/AbstractPropertiesCommandLineConverter.classPK A}yGK1.oorg/gradle/cli/CommandLineArgumentException.classPK Ag)porg/gradle/cli/CommandLineConverter.classPK ASf g&$rorg/gradle/cli/CommandLineOption.classPK A튯(jxorg/gradle/cli/CommandLineParser$1.classPK AƭN ;Uyorg/gradle/cli/CommandLineParser$AfterFirstSubCommand.classPK AD&3|org/gradle/cli/CommandLineParser$AfterOptions.classPK A <org/gradle/cli/CommandLineParser$BeforeFirstSubCommand.classPK A*ZMFJorg/gradle/cli/CommandLineParser$CaseInsensitiveStringComparator.classPK A2 =org/gradle/cli/CommandLineParser$KnownOptionParserState.classPK A$ľ<Zorg/gradle/cli/CommandLineParser$MissingOptionArgState.classPK ATK>=Yorg/gradle/cli/CommandLineParser$OptionAwareParserState.classPK A%̻7^org/gradle/cli/CommandLineParser$OptionComparator.classPK AfC8norg/gradle/cli/CommandLineParser$OptionParserState.classPK AE3korg/gradle/cli/CommandLineParser$OptionString.classPK AgAqx=gorg/gradle/cli/CommandLineParser$OptionStringComparator.classPK A`M~U2Vorg/gradle/cli/CommandLineParser$ParserState.classPK ApX k?org/gradle/cli/CommandLineParser$UnknownOptionParserState.classPK AdZl)&org/gradle/cli/CommandLineParser.classPK A>&>org/gradle/cli/ParsedCommandLine.classPK AytE,Korg/gradle/cli/ParsedCommandLineOption.classPK A\vB| :oorg/gradle/cli/ProjectPropertiesCommandLineConverter.classPK A 8=|9Corg/gradle/cli/SystemPropertiesCommandLineConverter.classPK AWgradle-cli-classpath.propertiesPK11gjava-db-3.2.5/gradle/wrapper/gradle-wrapper.properties000066400000000000000000000003501365011601400227700ustar00rootroot00000000000000#Mon Jul 29 10:43:26 EDT 2019 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists distributionUrl=https\://services.gradle.org/distributions/gradle-5.1.1-all.zip java-db-3.2.5/gradlew000077500000000000000000000122711365011601400144000ustar00rootroot00000000000000#!/usr/bin/env sh ############################################################################## ## ## 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"' # 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, switch paths to Windows format before running java if $cygwin ; 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=$((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" # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then cd "$(dirname "$0")" fi exec "$JAVACMD" "$@" java-db-3.2.5/gradlew.bat000066400000000000000000000043351365011601400151440ustar00rootroot00000000000000@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 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" @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.2.5/scripts/000077500000000000000000000000001365011601400145115ustar00rootroot00000000000000java-db-3.2.5/scripts/clean.sh000077500000000000000000000000661365011601400161340ustar00rootroot00000000000000#!/bin/bash ./gradlew clean rm -rf out 2>/dev/null java-db-3.2.5/scripts/make-jar.sh000077500000000000000000000002351365011601400165370ustar00rootroot00000000000000#!/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.2.5/scripts/run-tests.sh000077500000000000000000000000351365011601400170120ustar00rootroot00000000000000#!/bin/bash ./gradlew test java-db-3.2.5/settings.gradle000066400000000000000000000000341365011601400160370ustar00rootroot00000000000000rootProject.name = 'java-db'java-db-3.2.5/src/000077500000000000000000000000001365011601400136115ustar00rootroot00000000000000java-db-3.2.5/src/main/000077500000000000000000000000001365011601400145355ustar00rootroot00000000000000java-db-3.2.5/src/main/java/000077500000000000000000000000001365011601400154565ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/000077500000000000000000000000001365011601400162345ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/000077500000000000000000000000001365011601400211145ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/database/000077500000000000000000000000001365011601400226605ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/database/Database.java000066400000000000000000000001541365011601400252270ustar00rootroot00000000000000package com.softwareverde.database; public interface Database extends DatabaseConnectionFactory { } java-db-3.2.5/src/main/java/com/softwareverde/database/DatabaseConnection.java000066400000000000000000000017021365011601400272470ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/DatabaseConnectionFactory.java000066400000000000000000000002331365011601400305750ustar00rootroot00000000000000package com.softwareverde.database; public interface DatabaseConnectionFactory { DatabaseConnection newConnection() throws DatabaseException; } java-db-3.2.5/src/main/java/com/softwareverde/database/DatabaseException.java000066400000000000000000000006221365011601400271060ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/DatabaseInitializer.java000066400000000000000000000016271365011601400274410ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/KeyValueStore.java000066400000000000000000000003541365011601400262670ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/jdbc/000077500000000000000000000000001365011601400235625ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/database/jdbc/JdbcDatabase.java000066400000000000000000000004641365011601400267200ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/jdbc/JdbcDatabaseConnection.java000066400000000000000000000170541365011601400307430ustar00rootroot00000000000000package 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; } } } 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() ) { if (resultSet.first()) { do { results.add(_rowFactory.fromResultSet(resultSet)); } while (resultSet.next()); } } 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.2.5/src/main/java/com/softwareverde/database/jdbc/JdbcDatabaseConnectionFactory.java000066400000000000000000000005561365011601400322720ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/jdbc/row/000077500000000000000000000000001365011601400243715ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/database/jdbc/row/JdbcRow.java000066400000000000000000000113531365011601400265710ustar00rootroot00000000000000package 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.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.type == ParameterType.BYTE_ARRAY) { return new String((byte[]) value.value, CHARSET); } else if (value.type != ParameterType.STRING) { return ( (value.value != null) ? value.value.toString() : null); } 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; } } java-db-3.2.5/src/main/java/com/softwareverde/database/jdbc/row/JdbcRowFactory.java000066400000000000000000000075361365011601400301310ustar00rootroot00000000000000package 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; public class JdbcRowFactory implements RowFactory { 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 { 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.2.5/src/main/java/com/softwareverde/database/jdbc/transaction/000077500000000000000000000000001365011601400261075ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/database/jdbc/transaction/DatabaseCallable.java000066400000000000000000000005171365011601400321010ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/jdbc/transaction/DatabaseRunnable.java000066400000000000000000000004421365011601400321450ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/jdbc/transaction/JdbcDatabaseTransaction.java000066400000000000000000000045531365011601400334560ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/properties/000077500000000000000000000000001365011601400250545ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/database/properties/DatabaseCredentials.java000066400000000000000000000004631365011601400316040ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/properties/DatabaseProperties.java000066400000000000000000000005141365011601400315000ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/properties/MutableDatabaseProperties.java000066400000000000000000000035621365011601400330200ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/query/000077500000000000000000000000001365011601400240255ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/database/query/BatchedInsertQuery.java000066400000000000000000000110671365011601400304420ustar00rootroot00000000000000package 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.Matcher; 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.2.5/src/main/java/com/softwareverde/database/query/BatchedUpdateQuery.java000066400000000000000000000040731365011601400304170ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/query/ParameterFactoryCore.java000066400000000000000000000037051365011601400307560ustar00rootroot00000000000000package 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; 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 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.2.5/src/main/java/com/softwareverde/database/query/Query.java000066400000000000000000000350371365011601400260050ustar00rootroot00000000000000package com.softwareverde.database.query; import com.softwareverde.constable.bytearray.ByteArray; import com.softwareverde.constable.list.List; 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.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 MutableList(); protected final MutableList _inClauseParameterIndexes = new MutableList(); protected Integer _nextParameterIndex = 0; protected void _setInClauseParameters(final InClauseParameter inClauseParameter, final InClauseParameter[] extraInClauseParameters, final Boolean enableExpandedInClause) { final MutableList valueTuples = new MutableList((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 MutableList(); 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 MutableList(query._parameters); } _parameterFactory = parameterFactory; } protected Query(final String query, final ParameterFactory parameterFactory) { _query = query; _parameters = new MutableList(); _parameterFactory = parameterFactory; } public Query(final Query query) { this(query, false, new ParameterFactoryCore()); } public Query(final String query) { _query = query; _parameters = new MutableList(); _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 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 MutableList(); 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.2.5/src/main/java/com/softwareverde/database/query/ValueExtractor.java000066400000000000000000000057341365011601400276510ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/query/parameter/000077500000000000000000000000001365011601400260055ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/database/query/parameter/InClauseParameter.java000066400000000000000000000031251365011601400322150ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/query/parameter/ParameterFactory.java000066400000000000000000000002111365011601400321120ustar00rootroot00000000000000package com.softwareverde.database.query.parameter; public interface ParameterFactory { TypedParameter fromObject(Object object); } java-db-3.2.5/src/main/java/com/softwareverde/database/query/parameter/ParameterType.java000066400000000000000000000002171365011601400314320ustar00rootroot00000000000000package com.softwareverde.database.query.parameter; public enum ParameterType { BYTE_ARRAY, STRING, WHOLE_NUMBER, FLOATING_POINT_NUMBER } java-db-3.2.5/src/main/java/com/softwareverde/database/query/parameter/TypedParameter.java000066400000000000000000000046721365011601400316070ustar00rootroot00000000000000package com.softwareverde.database.query.parameter; 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 a 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; } } java-db-3.2.5/src/main/java/com/softwareverde/database/row/000077500000000000000000000000001365011601400234675ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/database/row/Row.java000066400000000000000000000006321365011601400251020ustar00rootroot00000000000000package com.softwareverde.database.row; 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); } java-db-3.2.5/src/main/java/com/softwareverde/database/row/RowFactory.java000066400000000000000000000003461365011601400264340ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/transaction/000077500000000000000000000000001365011601400252055ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/database/transaction/DatabaseTransaction.java000066400000000000000000000010161365011601400317600ustar00rootroot00000000000000package 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.2.5/src/main/java/com/softwareverde/database/util/000077500000000000000000000000001365011601400236355ustar00rootroot00000000000000java-db-3.2.5/src/main/java/com/softwareverde/database/util/DatabaseUtil.java000066400000000000000000000046741365011601400270550ustar00rootroot00000000000000package com.softwareverde.database.util; import com.softwareverde.constable.list.List; import com.softwareverde.constable.list.immutable.ImmutableListBuilder; import com.softwareverde.database.row.Row; import com.softwareverde.util.Util; import java.util.Collection; 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.2.5/src/main/java/com/softwareverde/database/util/TransactionUtil.java000066400000000000000000000026721365011601400276320ustar00rootroot00000000000000package 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.2.5/src/test/000077500000000000000000000000001365011601400145705ustar00rootroot00000000000000java-db-3.2.5/src/test/java/000077500000000000000000000000001365011601400155115ustar00rootroot00000000000000java-db-3.2.5/src/test/java/com/000077500000000000000000000000001365011601400162675ustar00rootroot00000000000000java-db-3.2.5/src/test/java/com/softwareverde/000077500000000000000000000000001365011601400211475ustar00rootroot00000000000000java-db-3.2.5/src/test/java/com/softwareverde/database/000077500000000000000000000000001365011601400227135ustar00rootroot00000000000000java-db-3.2.5/src/test/java/com/softwareverde/database/QueryTests.java000066400000000000000000000372761365011601400257250ustar00rootroot00000000000000package com.softwareverde.database; 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 MutableList>(); 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 MutableList>(); 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 MutableList(); 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 MutableList>(); 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 MutableList>(); 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 MutableList>(); 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.2.5/src/test/java/com/softwareverde/database/jdbc/000077500000000000000000000000001365011601400236155ustar00rootroot00000000000000java-db-3.2.5/src/test/java/com/softwareverde/database/jdbc/transaction/000077500000000000000000000000001365011601400261425ustar00rootroot00000000000000JdbcDatabaseTransactionTests.java000066400000000000000000000166721365011601400344620ustar00rootroot00000000000000java-db-3.2.5/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.2.5/src/test/java/com/softwareverde/database/memory/000077500000000000000000000000001365011601400242235ustar00rootroot00000000000000java-db-3.2.5/src/test/java/com/softwareverde/database/memory/mysql/000077500000000000000000000000001365011601400253705ustar00rootroot00000000000000java-db-3.2.5/src/test/java/com/softwareverde/database/memory/mysql/MysqlMemoryDatabase.java000066400000000000000000000025071365011601400321620ustar00rootroot00000000000000package 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.java000066400000000000000000000125571365011601400341310ustar00rootroot00000000000000java-db-3.2.5/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.*; 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.2.5/src/test/java/com/softwareverde/database/memory/mysql/MysqlMemoryRow.java000066400000000000000000000046241365011601400312270ustar00rootroot00000000000000package 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.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)); } } java-db-3.2.5/src/test/java/com/softwareverde/database/query/000077500000000000000000000000001365011601400240605ustar00rootroot00000000000000java-db-3.2.5/src/test/java/com/softwareverde/database/query/BatchedInsertQueryTests.java000066400000000000000000000107161365011601400315200ustar00rootroot00000000000000package 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); } }